View Javadoc
1   /* Generated By:JJTree&JavaCC: Do not edit this line. PLSQLParser.java */
2   /* Copyright (C) 2002 Albert Tumanov
3   
4   This library is free software; you can redistribute it and/or
5   modify it under the terms of the GNU Lesser General Public
6   License as published by the Free Software Foundation; either
7   version 2.1 of the License, or (at your option) any later version.
8   
9   This library is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  Lesser General Public License for more details.
13  
14  You should have received a copy of the GNU Lesser General Public
15  License along with this library; if not, write to the Free Software
16  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  
18  */
19  
20  package net.sourceforge.pmd.lang.plsql.ast;
21  
22  import java.io.*;
23  import net.sourceforge.pmd.lang.ast.Node;
24  import net.sourceforge.pmd.lang.ast.SimpleCharStream;
25  import net.sourceforge.pmd.lang.ast.TokenMgrError;
26  
27  public class PLSQLParser/*@bgen(jjtree)*/implements PLSQLParserTreeConstants, PLSQLParserConstants {/*@bgen(jjtree)*/
28    protected JJTPLSQLParserState jjtree = new JJTPLSQLParserState();
29    /**
30     * main method, for testing only.
31     * @param args
32     */
33    public static void main(String[] args)
34        throws ParseException {
35  
36      PLSQLParser parser = new PLSQLParser(System.in);
37      PLSQLNode node = parser.Input();
38  
39      String s;
40      s = "qwerty";
41  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
42      s = "\u005c"qwerty\u005c"";
43  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
44      s = "\u005c"qwerty\u005c".uiop";
45  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
46      s = "\u005c"qwerty\u005c".\u005c"uiop\u005c"";
47  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
48    }
49  
50    /**
51     Return canonical version of the Oracle
52    */
53    public static String canonicalName(String name)
54    {
55      StringBuilder s =  null ;
56  
57  
58      if (null == name) {
59        return name;
60      }
61      else if (-1 == name.indexOf('"') )
62      {
63        name = name.toUpperCase();
64        s = new StringBuilder(name.trim());
65      }
66      else
67      {
68        StringBuilder oldString = new StringBuilder( name.trim().length());
69        s = new StringBuilder(name.trim());
70        boolean quotedCharacter = false ;
71        for (int i=0; i<oldString.length(); i++) {
72          if (oldString.charAt(i) == '"')
73          {
74  
75            oldString.deleteCharAt(i);
76            i--;
77  
78            //Toggle whether following characters are quoted or not
79            quotedCharacter = !quotedCharacter ;
80          }
81          else
82          {
83            s.append( quotedCharacter
84                      ? s.charAt(i)
85                      : Character.toUpperCase(s.charAt(i))
86                    );
87          }
88        }
89      }
90      return s.toString();
91    }
92  
93  /**
94   * 2006-05-22 - Matthias Hendler - Added parsing of triggers and global functions/procedures
95   *                                 Refactored printing of custom tags into the XML/DOM.
96   *                                 Custom tags are language independent. Reserved tags are linked
97   *                                 to the documented language like RETURN, PARAM and THROWS.
98   */
99  
100 /**
101  * 2006-05-22 - Matthias Hendler - added globalBody()
102  */
103   final public ASTInput Input() throws ParseException {
104                     /*@bgen(jjtree) Input */
105   ASTInput jjtn000 = new ASTInput(this, JJTINPUT);
106   boolean jjtc000 = true;
107   jjtree.openNodeScope(jjtn000);
108     try {
109       label_1:
110       while (true) {
111         switch (jj_nt.kind) {
112         case 2:
113         case 3:
114         case 21:
115         case ALTER:
116         case BEGIN:
117         case COLUMN:
118         case COMMENT:
119         case COMMIT:
120         case CONNECT:
121         case CREATE:
122         case DECLARE:
123         case DELETE:
124         case DROP:
125         case EXECUTE:
126         case EXIT:
127         case FUNCTION:
128         case GRANT:
129         case INSERT:
130         case LOCK:
131         case MERGE:
132         case PACKAGE:
133         case PROMPT:
134         case PROCEDURE:
135         case RENAME:
136         case REVOKE:
137         case ROLLBACK:
138         case SAVEPOINT:
139         case SELECT:
140         case SET:
141         case START:
142         case TRIGGER:
143         case TYPE:
144         case SHOW:
145         case SPOOL:
146         case UPDATE:
147         case WITH:
148         case ANALYZE:
149         case ASSOCIATE:
150         case AUDIT:
151         case DDL:
152         case DISASSOCIATE:
153         case NOAUDIT:
154         case TRUNCATE:
155         case ACCEPT:
156         case COPY:
157         case DEFINE:
158         case DISCONNECT:
159         case HOST:
160         case PRINT:
161         case QUIT:
162         case REMARK:
163         case UNDEFINE:
164         case VARIABLE:
165         case WHENEVER:
166         case IDENTIFIER:
167           ;
168           break;
169         default:
170           jj_la1[0] = jj_gen;
171           break label_1;
172         }
173         if (jj_2_1(7)) {
174           PackageSpecification();
175         } else if (jj_2_2(7)) {
176           PackageBody();
177         } else if (jj_2_3(6)) {
178           TypeSpecification();
179         } else if (jj_2_4(6)) {
180           Table();
181         } else if (jj_2_5(6)) {
182           View();
183         } else if (jj_2_6(6)) {
184           TriggerUnit();
185         } else if (jj_2_7(6)) {
186           AlterTrigger();
187         } else if (jj_2_8(6)) {
188           Synonym();
189         } else if (jj_2_9(6)) {
190           Directory();
191         } else if (jj_2_10(6)) {
192           DatabaseLink();
193         } else if (jj_2_11(6)) {
194           Global();
195         } else if (jj_2_12(6)) {
196           DDLCommand();
197         } else if (jj_2_13(2)) {
198           SqlPlusCommand();
199         } else {
200           switch (jj_nt.kind) {
201           case COMMIT:
202           case DELETE:
203           case INSERT:
204           case LOCK:
205           case MERGE:
206           case ROLLBACK:
207           case SAVEPOINT:
208           case SELECT:
209           case UPDATE:
210           case WITH:
211             switch (jj_nt.kind) {
212             case SELECT:
213               jj_consume_token(SELECT);
214               break;
215             case UPDATE:
216               jj_consume_token(UPDATE);
217               break;
218             case INSERT:
219               jj_consume_token(INSERT);
220               break;
221             case DELETE:
222               jj_consume_token(DELETE);
223               break;
224             case COMMIT:
225               jj_consume_token(COMMIT);
226               break;
227             case ROLLBACK:
228               jj_consume_token(ROLLBACK);
229               break;
230             case SAVEPOINT:
231               jj_consume_token(SAVEPOINT);
232               break;
233             case LOCK:
234               jj_consume_token(LOCK);
235               jj_consume_token(TABLE);
236               break;
237             case MERGE:
238               jj_consume_token(MERGE);
239               break;
240             case WITH:
241               jj_consume_token(WITH);
242               break;
243             default:
244               jj_la1[1] = jj_gen;
245               jj_consume_token(-1);
246               throw new ParseException();
247             }
248             SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
249             break;
250           default:
251             jj_la1[2] = jj_gen;
252             jj_consume_token(-1);
253             throw new ParseException();
254           }
255         }
256         label_2:
257         while (true) {
258           switch (jj_nt.kind) {
259           case 1:
260             ;
261             break;
262           default:
263             jj_la1[3] = jj_gen;
264             break label_2;
265           }
266           jj_consume_token(1);
267         }
268       }
269       jj_consume_token(0);
270         jjtree.closeNodeScope(jjtn000, true);
271         jjtc000 = false;
272         {if (true) return jjtn000 ;}
273     } catch (Throwable jjte000) {
274           if (jjtc000) {
275             jjtree.clearNodeScope(jjtn000);
276             jjtc000 = false;
277           } else {
278             jjtree.popNode();
279           }
280           if (jjte000 instanceof RuntimeException) {
281             {if (true) throw (RuntimeException)jjte000;}
282           }
283           if (jjte000 instanceof ParseException) {
284             {if (true) throw (ParseException)jjte000;}
285           }
286           {if (true) throw (Error)jjte000;}
287     } finally {
288           if (jjtc000) {
289             jjtree.closeNodeScope(jjtn000, true);
290           }
291     }
292     throw new Error("Missing return statement in function");
293   }
294 
295   final public ASTDDLCommand DDLCommand() throws ParseException {
296  /*@bgen(jjtree) DDLCommand */
297  ASTDDLCommand jjtn000 = new ASTDDLCommand(this, JJTDDLCOMMAND);
298  boolean jjtc000 = true;
299  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
300     try {
301       simpleNode = DDLEvent();
302       SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
303     jjtree.closeNodeScope(jjtn000, true);
304     jjtc000 = false;
305     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
306     } catch (Throwable jjte000) {
307     if (jjtc000) {
308       jjtree.clearNodeScope(jjtn000);
309       jjtc000 = false;
310     } else {
311       jjtree.popNode();
312     }
313     if (jjte000 instanceof RuntimeException) {
314       {if (true) throw (RuntimeException)jjte000;}
315     }
316     if (jjte000 instanceof ParseException) {
317       {if (true) throw (ParseException)jjte000;}
318     }
319     {if (true) throw (Error)jjte000;}
320     } finally {
321     if (jjtc000) {
322       jjtree.closeNodeScope(jjtn000, true);
323     }
324     }
325     throw new Error("Missing return statement in function");
326   }
327 
328   final public ASTSqlPlusCommand SqlPlusCommand() throws ParseException {
329  /*@bgen(jjtree) SqlPlusCommand */
330  ASTSqlPlusCommand jjtn000 = new ASTSqlPlusCommand(this, JJTSQLPLUSCOMMAND);
331  boolean jjtc000 = true;
332  jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder() ;
333     try {
334       switch (jj_nt.kind) {
335       case 2:
336         jj_consume_token(2);
337         break;
338       case ACCEPT:
339         jj_consume_token(ACCEPT);
340         break;
341       case COLUMN:
342         jj_consume_token(COLUMN);
343         break;
344       case CONNECT:
345         jj_consume_token(CONNECT);
346         break;
347       case COPY:
348         jj_consume_token(COPY);
349         break;
350       case DEFINE:
351         jj_consume_token(DEFINE);
352         break;
353       case DISCONNECT:
354         jj_consume_token(DISCONNECT);
355         break;
356       case EXECUTE:
357         jj_consume_token(EXECUTE);
358         break;
359       case EXIT:
360         jj_consume_token(EXIT);
361         break;
362       case HOST:
363         jj_consume_token(HOST);
364         break;
365       case PRINT:
366         jj_consume_token(PRINT);
367         break;
368       case PROMPT:
369         jj_consume_token(PROMPT);
370         break;
371       case QUIT:
372         jj_consume_token(QUIT);
373         break;
374       case REMARK:
375         jj_consume_token(REMARK);
376         break;
377       case SET:
378         jj_consume_token(SET);
379         break;
380       case SHOW:
381         jj_consume_token(SHOW);
382         break;
383       case SPOOL:
384         jj_consume_token(SPOOL);
385         break;
386       case START:
387         jj_consume_token(START);
388         break;
389       case UNDEFINE:
390         jj_consume_token(UNDEFINE);
391         break;
392       case VARIABLE:
393         jj_consume_token(VARIABLE);
394         break;
395       case WHENEVER:
396         jj_consume_token(WHENEVER);
397         break;
398       case COMMENT:
399         jj_consume_token(COMMENT);
400         break;
401       case GRANT:
402         jj_consume_token(GRANT);
403         break;
404       case REVOKE:
405         jj_consume_token(REVOKE);
406         break;
407       case DROP:
408         jj_consume_token(DROP);
409         break;
410       case IDENTIFIER:
411         jj_consume_token(IDENTIFIER);
412         break;
413       case 3:
414         jj_consume_token(3);
415         jj_consume_token(ATTACH);
416         break;
417       default:
418         jj_la1[4] = jj_gen;
419         jj_consume_token(-1);
420         throw new ParseException();
421       }
422     sb.append(token.image) ; sb.append(" ...") ;
423       Skip2NextTokenOccurrence(EOL);
424     jjtree.closeNodeScope(jjtn000, true);
425     jjtc000 = false;
426     jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
427     } catch (Throwable jjte000) {
428     if (jjtc000) {
429       jjtree.clearNodeScope(jjtn000);
430       jjtc000 = false;
431     } else {
432       jjtree.popNode();
433     }
434     if (jjte000 instanceof RuntimeException) {
435       {if (true) throw (RuntimeException)jjte000;}
436     }
437     if (jjte000 instanceof ParseException) {
438       {if (true) throw (ParseException)jjte000;}
439     }
440     {if (true) throw (Error)jjte000;}
441     } finally {
442     if (jjtc000) {
443       jjtree.closeNodeScope(jjtn000, true);
444     }
445     }
446     throw new Error("Missing return statement in function");
447   }
448 
449 /*
450 SRT 2011-04-17 This syntax breaks the parser when fields of record.attach* are referenced  in PL/SQL 
451 void attachLibrary() :
452 {}
453 {
454 	<".attach"> <IDENTIFIER> <IDENTIFIER> <END> <IDENTIFIER>
455 }
456 */
457 
458 /**
459  * All global definitions of triggers, functions and procedures are evaluated here.
460  * Every occurence goes under a new PACKAGE-Node in the XML document.
461  * This happens, cause a global "block" does not have a definied start and end token 
462  * like a package specification or a package body.
463  * Thats why every construct is handled like a new part of the global package.
464  * To overcome this problem, I could use an infinity lookahead - which should solve the problem 
465  * and slow down the whole parsing.
466  * Another idea would be to lookahead the next tokens and decide wether they belong to a package definition or not.
467  * Then I could decide to stay in this global parsing state. By now lookahead gives the parser a hint to
468  * choose the correct way on a given base. So we can't negate it easily.
469  * On the other hand I could also hold the global state in a global variable. 
470  * But this does not seems the correct way to solve the problem, I think.
471  *
472  * 2006-05-17 - Matthias Hendler - added
473  */
474   final public ASTGlobal Global() throws ParseException {
475  /*@bgen(jjtree) Global */
476   ASTGlobal jjtn000 = new ASTGlobal(this, JJTGLOBAL);
477   boolean jjtc000 = true;
478   jjtree.openNodeScope(jjtn000);
479     try {
480       if (jj_2_14(2147483647)) {
481         label_3:
482         while (true) {
483           switch (jj_nt.kind) {
484           case 21:
485             ;
486             break;
487           default:
488             jj_la1[5] = jj_gen;
489             break label_3;
490           }
491           Label();
492         }
493         Block();
494         jj_consume_token(4);
495       } else if (jj_2_15(4)) {
496         ProgramUnit();
497       } else {
498         jj_consume_token(-1);
499         throw new ParseException();
500       }
501         jjtree.closeNodeScope(jjtn000, true);
502         jjtc000 = false;
503         {if (true) return jjtn000 ;}
504     } catch (Throwable jjte000) {
505           if (jjtc000) {
506             jjtree.clearNodeScope(jjtn000);
507             jjtc000 = false;
508           } else {
509             jjtree.popNode();
510           }
511           if (jjte000 instanceof RuntimeException) {
512             {if (true) throw (RuntimeException)jjte000;}
513           }
514           if (jjte000 instanceof ParseException) {
515             {if (true) throw (ParseException)jjte000;}
516           }
517           {if (true) throw (Error)jjte000;}
518     } finally {
519           if (jjtc000) {
520             jjtree.closeNodeScope(jjtn000, true);
521           }
522     }
523     throw new Error("Missing return statement in function");
524   }
525 
526   final public ASTBlock Block() throws ParseException {
527  /*@bgen(jjtree) Block */
528   ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
529   boolean jjtc000 = true;
530   jjtree.openNodeScope(jjtn000);
531     try {
532       switch (jj_nt.kind) {
533       case DECLARE:
534         jj_consume_token(DECLARE);
535         DeclarativeSection();
536         break;
537       default:
538         jj_la1[6] = jj_gen;
539         ;
540       }
541       jj_consume_token(BEGIN);
542       label_4:
543       while (true) {
544         switch (jj_nt.kind) {
545         case 5:
546         case 16:
547         case 17:
548         case 21:
549         case REPLACE:
550         case DEFINER:
551         case CURRENT_USER:
552         case LANGUAGE:
553         case INLINE:
554         case ADD:
555         case AGGREGATE:
556         case ARRAY:
557         case AT:
558         case ATTRIBUTE:
559         case AUTHID:
560         case BEGIN:
561         case BODY:
562         case BULK:
563         case BYTE:
564         case CASCADE:
565         case CASE:
566         case CLOSE:
567         case COALESCE:
568         case COLLECT:
569         case COLUMN:
570         case COMMENT:
571         case COMMIT:
572         case CONSTRUCTOR:
573         case CONTINUE:
574         case CONVERT:
575         case CURRENT:
576         case CURSOR:
577         case DATA:
578         case DATE:
579         case DAY:
580         case DECLARE:
581         case DELETE:
582         case DISABLE:
583         case EDITIONABLE:
584         case ELEMENT:
585         case ENABLE:
586         case ESCAPE:
587         case EXCEPT:
588         case EXCEPTIONS:
589         case EXECUTE:
590         case EXIT:
591         case EXTERNAL:
592         case EXTENDS:
593         case EXTRACT:
594         case FALSE:
595         case FETCH:
596         case FINAL:
597         case FOR:
598         case FORALL:
599         case FORCE:
600         case FUNCTION:
601         case GLOBAL:
602         case GOTO:
603         case HASH:
604         case HEAP:
605         case HOUR:
606         case IF:
607         case IMMEDIATE:
608         case INDICES:
609         case INDEXTYPE:
610         case INDICATOR:
611         case INSERT:
612         case INSTANTIABLE:
613         case INTERVAL:
614         case INVALIDATE:
615         case ISOLATION:
616         case JAVA:
617         case LEVEL:
618         case LIMIT:
619         case LOCK:
620         case LOOP:
621         case MAP:
622         case MAX:
623         case MEMBER:
624         case MERGE:
625         case MIN:
626         case MINUTE:
627         case MLSLABEL:
628         case MODIFY:
629         case MOD:
630         case MONTH:
631         case NATURAL:
632         case NEW:
633         case NEW_DOT:
634         case NO:
635         case NONEDITIONABLE:
636         case NOT:
637         case NULL:
638         case NULLIF:
639         case OBJECT:
640         case OID:
641         case OPAQUE:
642         case OPEN:
643         case OPERATOR:
644         case ORGANIZATION:
645         case OTHERS:
646         case OVERRIDING:
647         case PACKAGE:
648         case PARTITION:
649         case PIPE:
650         case PRAGMA:
651         case PRESERVE:
652         case PRIVATE:
653         case PROCEDURE:
654         case RAISE:
655         case RANGE:
656         case RAW:
657         case REAL:
658         case RECORD:
659         case REF:
660         case RELEASE:
661         case RELIES_ON:
662         case RENAME:
663         case RESULT:
664         case RETURN:
665         case RETURNING:
666         case REVERSE:
667         case ROLLBACK:
668         case ROW:
669         case ROWS:
670         case ROWID:
671         case ROWNUM:
672         case SAVE:
673         case SAVEPOINT:
674         case SECOND:
675         case SELECT:
676         case SELF:
677         case SET:
678         case SPACE:
679         case SQL:
680         case SQLCODE:
681         case SQLERRM:
682         case STATIC:
683         case SUBTYPE:
684         case SUBSTITUTABLE:
685         case SUCCESSFUL:
686         case SYSDATE:
687         case SYS_REFCURSOR:
688         case TEMPORARY:
689         case TIME:
690         case TIMESTAMP:
691         case TIMEZONE_REGION:
692         case TIMEZONE_ABBR:
693         case TIMEZONE_MINUTE:
694         case TIMEZONE_HOUR:
695         case TRANSACTION:
696         case TRUE:
697         case TYPE:
698         case UNDER:
699         case USING:
700         case WHILE:
701         case YES:
702         case SHOW:
703         case A:
704         case UPDATE:
705         case DOUBLE:
706         case DEC:
707         case PRECISION:
708         case INT:
709         case NUMERIC:
710         case NCHAR:
711         case NVARCHAR2:
712         case STRING:
713         case UROWID:
714         case VARRAY:
715         case VARYING:
716         case BFILE:
717         case BLOB:
718         case CLOB:
719         case NCLOB:
720         case YEAR:
721         case LOCAL:
722         case WITH:
723         case ZONE:
724         case CHARACTER:
725         case AFTER:
726         case BEFORE:
727         case OLD:
728         case PARENT:
729         case CC_IF:
730         case CC_ERROR:
731         case ANALYZE:
732         case ASSOCIATE:
733         case AUDIT:
734         case COMPOUND:
735         case DATABASE:
736         case CALL:
737         case DDL:
738         case DISASSOCIATE:
739         case EACH:
740         case FOLLOWS:
741         case LOGOFF:
742         case LOGON:
743         case NESTED:
744         case NOAUDIT:
745         case SCHEMA:
746         case SERVERERROR:
747         case SHUTDOWN:
748         case STARTUP:
749         case STATEMENT:
750         case STATISTICS:
751         case SUSPEND:
752         case TRUNCATE:
753         case WRAPPED:
754         case LIBRARY:
755         case NAME:
756         case STRUCT:
757         case CONTEXT:
758         case PARAMETERS:
759         case LENGTH:
760         case TDO:
761         case MAXLEN:
762         case CHARSETID:
763         case CHARSETFORM:
764         case ACCEPT:
765         case ACCESSIBLE:
766         case COPY:
767         case DEFINE:
768         case DISCONNECT:
769         case HOST:
770         case PRINT:
771         case QUIT:
772         case REMARK:
773         case UNDEFINE:
774         case VARIABLE:
775         case WHENEVER:
776         case ATTACH:
777         case CAST:
778         case TREAT:
779         case TRIM:
780         case LEFT:
781         case RIGHT:
782         case BOTH:
783         case EMPTY:
784         case MULTISET:
785         case SUBMULTISET:
786         case LEADING:
787         case TRAILING:
788         case CHAR_CS:
789         case NCHAR_CS:
790         case DBTIMEZONE:
791         case SESSIONTIMEZONE:
792         case AUTHENTICATED:
793         case LINK:
794         case SHARED:
795         case DIRECTORY:
796         case USER:
797         case IDENTIFIER:
798         case UNSIGNED_NUMERIC_LITERAL:
799         case CHARACTER_LITERAL:
800         case STRING_LITERAL:
801         case QUOTED_LITERAL:
802           ;
803           break;
804         default:
805           jj_la1[7] = jj_gen;
806           break label_4;
807         }
808         Statement();
809       }
810       switch (jj_nt.kind) {
811       case EXCEPTION:
812         ExceptionHandler();
813         break;
814       default:
815         jj_la1[8] = jj_gen;
816         ;
817       }
818       jj_consume_token(END);
819       switch (jj_nt.kind) {
820       case IDENTIFIER:
821         jj_consume_token(IDENTIFIER);
822         break;
823       default:
824         jj_la1[9] = jj_gen;
825         ;
826       }
827       jjtree.closeNodeScope(jjtn000, true);
828       jjtc000 = false;
829       {if (true) return jjtn000 ;}
830     } catch (Throwable jjte000) {
831       if (jjtc000) {
832         jjtree.clearNodeScope(jjtn000);
833         jjtc000 = false;
834       } else {
835         jjtree.popNode();
836       }
837       if (jjte000 instanceof RuntimeException) {
838         {if (true) throw (RuntimeException)jjte000;}
839       }
840       if (jjte000 instanceof ParseException) {
841         {if (true) throw (ParseException)jjte000;}
842       }
843       {if (true) throw (Error)jjte000;}
844     } finally {
845       if (jjtc000) {
846         jjtree.closeNodeScope(jjtn000, true);
847       }
848     }
849     throw new Error("Missing return statement in function");
850   }
851 
852   final public ASTPackageSpecification PackageSpecification() throws ParseException {
853  /*@bgen(jjtree) PackageSpecification */
854  ASTPackageSpecification jjtn000 = new ASTPackageSpecification(this, JJTPACKAGESPECIFICATION);
855  boolean jjtc000 = true;
856  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
857     try {
858       switch (jj_nt.kind) {
859       case CREATE:
860         jj_consume_token(CREATE);
861         switch (jj_nt.kind) {
862         case OR:
863           jj_consume_token(OR);
864           jj_consume_token(REPLACE);
865           break;
866         default:
867           jj_la1[10] = jj_gen;
868           ;
869         }
870         switch (jj_nt.kind) {
871         case EDITIONABLE:
872         case NONEDITIONABLE:
873           switch (jj_nt.kind) {
874           case EDITIONABLE:
875             jj_consume_token(EDITIONABLE);
876             break;
877           case NONEDITIONABLE:
878             jj_consume_token(NONEDITIONABLE);
879             break;
880           default:
881             jj_la1[11] = jj_gen;
882             jj_consume_token(-1);
883             throw new ParseException();
884           }
885           break;
886         default:
887           jj_la1[12] = jj_gen;
888           ;
889         }
890         break;
891       default:
892         jj_la1[13] = jj_gen;
893         ;
894       }
895       jj_consume_token(PACKAGE);
896       simpleNode = ObjectNameDeclaration();
897       label_5:
898       while (true) {
899         switch (jj_nt.kind) {
900         case AUTHID:
901         case ACCESSIBLE:
902           ;
903           break;
904         default:
905           jj_la1[14] = jj_gen;
906           break label_5;
907         }
908         switch (jj_nt.kind) {
909         case AUTHID:
910           jj_consume_token(AUTHID);
911           switch (jj_nt.kind) {
912           case CURRENT_USER:
913             jj_consume_token(CURRENT_USER);
914             break;
915           case DEFINER:
916             jj_consume_token(DEFINER);
917             break;
918           default:
919             jj_la1[15] = jj_gen;
920             jj_consume_token(-1);
921             throw new ParseException();
922           }
923           break;
924         case ACCESSIBLE:
925           AccessibleByClause();
926           break;
927         default:
928           jj_la1[16] = jj_gen;
929           jj_consume_token(-1);
930           throw new ParseException();
931         }
932       }
933       switch (jj_nt.kind) {
934       case WRAPPED:
935         WrappedObject();
936         break;
937       case AS:
938       case IS:
939         switch (jj_nt.kind) {
940         case IS:
941           jj_consume_token(IS);
942           break;
943         case AS:
944           jj_consume_token(AS);
945           break;
946         default:
947           jj_la1[17] = jj_gen;
948           jj_consume_token(-1);
949           throw new ParseException();
950         }
951         DeclarativeSection();
952         jj_consume_token(END);
953         switch (jj_nt.kind) {
954         case REPLACE:
955         case DEFINER:
956         case CURRENT_USER:
957         case SERIALLY_REUSABLE:
958         case RESTRICT_REFERENCES:
959         case EXCEPTION_INIT:
960         case AUTONOMOUS_TRANSACTION:
961         case LANGUAGE:
962         case INLINE:
963         case ADD:
964         case AGGREGATE:
965         case ALL:
966         case ALTER:
967         case AND:
968         case ANY:
969         case ARRAY:
970         case AS:
971         case ASC:
972         case AT:
973         case ATTRIBUTE:
974         case AUTHID:
975         case AVG:
976         case BETWEEN:
977         case BINARY_INTEGER:
978         case BODY:
979         case BOOLEAN:
980         case BULK:
981         case BY:
982         case BYTE:
983         case CASCADE:
984         case CASE:
985         case CHAR:
986         case CHAR_BASE:
987         case CHECK:
988         case CLOSE:
989         case CLUSTER:
990         case COALESCE:
991         case COLLECT:
992         case COLUMN:
993         case COMMENT:
994         case COMMIT:
995         case COMPRESS:
996         case CONNECT:
997         case CONSTANT:
998         case CONSTRUCTOR:
999         case CONTINUE:
1000         case CONVERT:
1001         case CREATE:
1002         case CURRENT:
1003         case CURRVAL:
1004         case CURSOR:
1005         case DATA:
1006         case DATE:
1007         case DAY:
1008         case DECLARE:
1009         case DECIMAL:
1010         case _DEFAULT:
1011         case DELETE:
1012         case DESC:
1013         case DISABLE:
1014         case DISTINCT:
1015         case DO:
1016         case DROP:
1017         case EDITIONABLE:
1018         case ELEMENT:
1019         case ELSE:
1020         case ELSIF:
1021         case ENABLE:
1022         case ESCAPE:
1023         case EXCEPT:
1024         case EXCEPTION:
1025         case EXCEPTIONS:
1026         case EXCLUSIVE:
1027         case EXECUTE:
1028         case EXISTS:
1029         case EXIT:
1030         case EXTERNAL:
1031         case EXTENDS:
1032         case EXTRACT:
1033         case FALSE:
1034         case FETCH:
1035         case FINAL:
1036         case FLOAT:
1037         case FOR:
1038         case FORALL:
1039         case FORCE:
1040         case FROM:
1041         case FUNCTION:
1042         case GLOBAL:
1043         case GOTO:
1044         case GROUP:
1045         case HASH:
1046         case HAVING:
1047         case HEAP:
1048         case HOUR:
1049         case IF:
1050         case IMMEDIATE:
1051         case IN:
1052         case INDEX:
1053         case INDICES:
1054         case INDEXTYPE:
1055         case INDICATOR:
1056         case INSERT:
1057         case INSTANTIABLE:
1058         case INTEGER:
1059         case INTERFACE:
1060         case INTERSECT:
1061         case INTERVAL:
1062         case INTO:
1063         case INVALIDATE:
1064         case IS:
1065         case ISOLATION:
1066         case JAVA:
1067         case LEVEL:
1068         case LIKE:
1069         case LIMIT:
1070         case LIMITED:
1071         case LOCK:
1072         case LONG:
1073         case LOOP:
1074         case MAP:
1075         case MAX:
1076         case MEMBER:
1077         case MERGE:
1078         case MIN:
1079         case MINUS:
1080         case MINUTE:
1081         case MLSLABEL:
1082         case MODIFY:
1083         case MOD:
1084         case MODE:
1085         case MONTH:
1086         case NATURAL:
1087         case NATURALN:
1088         case NEW:
1089         case NEXTVAL:
1090         case NO:
1091         case NOCOPY:
1092         case NONEDITIONABLE:
1093         case NOT:
1094         case NOWAIT:
1095         case NULL:
1096         case NULLIF:
1097         case NUMBER:
1098         case BFILE_BASE:
1099         case BLOB_BASE:
1100         case CLOB_BASE:
1101         case DATE_BASE:
1102         case NUMBER_BASE:
1103         case OBJECT:
1104         case OCIROWID:
1105         case OF:
1106         case OID:
1107         case ON:
1108         case OPAQUE:
1109         case OPEN:
1110         case OPERATOR:
1111         case OPTION:
1112         case OR:
1113         case ORDER:
1114         case ORGANIZATION:
1115         case OTHERS:
1116         case OUT:
1117         case OVERRIDING:
1118         case PACKAGE:
1119         case PARTITION:
1120         case PCTFREE:
1121         case PLS_INTEGER:
1122         case POSITIVE:
1123         case POSITIVEN:
1124         case PRESERVE:
1125         case PRIOR:
1126         case PROMPT:
1127         case PRIVATE:
1128         case PROCEDURE:
1129         case PUBLIC:
1130         case RAISE:
1131         case RANGE:
1132         case RAW:
1133         case REAL:
1134         case RECORD:
1135         case REF:
1136         case RELEASE:
1137         case RELIES_ON:
1138         case RENAME:
1139         case RESULT:
1140         case RETURN:
1141         case RETURNING:
1142         case REVERSE:
1143         case ROLLBACK:
1144         case ROW:
1145         case ROWS:
1146         case ROWID:
1147         case ROWNUM:
1148         case ROWTYPE:
1149         case SAVE:
1150         case SAVEPOINT:
1151         case SECOND:
1152         case SELECT:
1153         case SELF:
1154         case SEPARATE:
1155         case SET:
1156         case SHARE:
1157         case SMALLINT:
1158         case SPACE:
1159         case SQL:
1160         case SQLCODE:
1161         case SQLERRM:
1162         case START:
1163         case STATIC:
1164         case STDDEV:
1165         case SUBTYPE:
1166         case SUBSTITUTABLE:
1167         case SUCCESSFUL:
1168         case SUM:
1169         case SYNONYM:
1170         case SYSDATE:
1171         case SYS_REFCURSOR:
1172         case TABLE:
1173         case TEMPORARY:
1174         case THEN:
1175         case TIME:
1176         case TIMESTAMP:
1177         case TIMEZONE_REGION:
1178         case TIMEZONE_ABBR:
1179         case TIMEZONE_MINUTE:
1180         case TIMEZONE_HOUR:
1181         case TO:
1182         case TRANSACTION:
1183         case TRIGGER:
1184         case TRUE:
1185         case TYPE:
1186         case UI:
1187         case UNDER:
1188         case USING:
1189         case WHILE:
1190         case YES:
1191         case SHOW:
1192         case A:
1193         case UPDATE:
1194         case VARCHAR:
1195         case VARCHAR2:
1196         case DOUBLE:
1197         case DEC:
1198         case PRECISION:
1199         case INT:
1200         case NUMERIC:
1201         case SIGNTYPE:
1202         case NCHAR:
1203         case NVARCHAR2:
1204         case STRING:
1205         case UROWID:
1206         case VARRAY:
1207         case VARYING:
1208         case BFILE:
1209         case BLOB:
1210         case CLOB:
1211         case NCLOB:
1212         case YEAR:
1213         case LOCAL:
1214         case WITH:
1215         case ZONE:
1216         case CHARACTER:
1217         case AFTER:
1218         case BEFORE:
1219         case OLD:
1220         case PARENT:
1221         case ANALYZE:
1222         case ASSOCIATE:
1223         case AUDIT:
1224         case COMPOUND:
1225         case DATABASE:
1226         case CALL:
1227         case DDL:
1228         case DISASSOCIATE:
1229         case EACH:
1230         case FOLLOWS:
1231         case LOGOFF:
1232         case LOGON:
1233         case NESTED:
1234         case NOAUDIT:
1235         case SCHEMA:
1236         case SERVERERROR:
1237         case SHUTDOWN:
1238         case STARTUP:
1239         case STATEMENT:
1240         case STATISTICS:
1241         case SUSPEND:
1242         case TRUNCATE:
1243         case WRAPPED:
1244         case LIBRARY:
1245         case NAME:
1246         case STRUCT:
1247         case CONTEXT:
1248         case PARAMETERS:
1249         case LENGTH:
1250         case TDO:
1251         case MAXLEN:
1252         case CHARSETID:
1253         case CHARSETFORM:
1254         case ACCEPT:
1255         case ACCESSIBLE:
1256         case COPY:
1257         case DEFINE:
1258         case DISCONNECT:
1259         case HOST:
1260         case PRINT:
1261         case QUIT:
1262         case REMARK:
1263         case UNDEFINE:
1264         case VARIABLE:
1265         case WHENEVER:
1266         case ATTACH:
1267         case CAST:
1268         case TREAT:
1269         case TRIM:
1270         case LEFT:
1271         case RIGHT:
1272         case BOTH:
1273         case EMPTY:
1274         case MULTISET:
1275         case SUBMULTISET:
1276         case LEADING:
1277         case TRAILING:
1278         case CHAR_CS:
1279         case NCHAR_CS:
1280         case DBTIMEZONE:
1281         case SESSIONTIMEZONE:
1282         case AUTHENTICATED:
1283         case LINK:
1284         case SHARED:
1285         case DIRECTORY:
1286         case USER:
1287         case IDENTIFIER:
1288         case QUOTED_LITERAL:
1289         case SQLDATA_CLASS:
1290         case CUSTOMDATUM_CLASS:
1291         case ORADATA_CLASS:
1292         case JAVA_INTERFACE_CLASS:
1293           ID();
1294           break;
1295         default:
1296           jj_la1[18] = jj_gen;
1297           ;
1298         }
1299         jj_consume_token(4);
1300         break;
1301       default:
1302         jj_la1[19] = jj_gen;
1303         jj_consume_token(-1);
1304         throw new ParseException();
1305       }
1306         jjtree.closeNodeScope(jjtn000, true);
1307         jjtc000 = false;
1308         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
1309     } catch (Throwable jjte000) {
1310         if (jjtc000) {
1311           jjtree.clearNodeScope(jjtn000);
1312           jjtc000 = false;
1313         } else {
1314           jjtree.popNode();
1315         }
1316         if (jjte000 instanceof RuntimeException) {
1317           {if (true) throw (RuntimeException)jjte000;}
1318         }
1319         if (jjte000 instanceof ParseException) {
1320           {if (true) throw (ParseException)jjte000;}
1321         }
1322         {if (true) throw (Error)jjte000;}
1323     } finally {
1324         if (jjtc000) {
1325           jjtree.closeNodeScope(jjtn000, true);
1326         }
1327     }
1328     throw new Error("Missing return statement in function");
1329   }
1330 
1331   final public ASTPackageBody PackageBody() throws ParseException {
1332  /*@bgen(jjtree) PackageBody */
1333  ASTPackageBody jjtn000 = new ASTPackageBody(this, JJTPACKAGEBODY);
1334  boolean jjtc000 = true;
1335  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
1336     try {
1337       switch (jj_nt.kind) {
1338       case CREATE:
1339         jj_consume_token(CREATE);
1340         switch (jj_nt.kind) {
1341         case OR:
1342           jj_consume_token(OR);
1343           jj_consume_token(REPLACE);
1344           break;
1345         default:
1346           jj_la1[20] = jj_gen;
1347           ;
1348         }
1349         switch (jj_nt.kind) {
1350         case EDITIONABLE:
1351         case NONEDITIONABLE:
1352           switch (jj_nt.kind) {
1353           case EDITIONABLE:
1354             jj_consume_token(EDITIONABLE);
1355             break;
1356           case NONEDITIONABLE:
1357             jj_consume_token(NONEDITIONABLE);
1358             break;
1359           default:
1360             jj_la1[21] = jj_gen;
1361             jj_consume_token(-1);
1362             throw new ParseException();
1363           }
1364           break;
1365         default:
1366           jj_la1[22] = jj_gen;
1367           ;
1368         }
1369         break;
1370       default:
1371         jj_la1[23] = jj_gen;
1372         ;
1373       }
1374       switch (jj_nt.kind) {
1375       case PACKAGE:
1376         jj_consume_token(PACKAGE);
1377         break;
1378       case TYPE:
1379         jj_consume_token(TYPE);
1380         break;
1381       default:
1382         jj_la1[24] = jj_gen;
1383         jj_consume_token(-1);
1384         throw new ParseException();
1385       }
1386       jj_consume_token(BODY);
1387       simpleNode = ObjectNameDeclaration();
1388       switch (jj_nt.kind) {
1389       case WRAPPED:
1390         WrappedObject();
1391         break;
1392       case AS:
1393       case IS:
1394         switch (jj_nt.kind) {
1395         case IS:
1396           jj_consume_token(IS);
1397           break;
1398         case AS:
1399           jj_consume_token(AS);
1400           break;
1401         default:
1402           jj_la1[25] = jj_gen;
1403           jj_consume_token(-1);
1404           throw new ParseException();
1405         }
1406         DeclarativeSection();
1407         switch (jj_nt.kind) {
1408         case BEGIN:
1409           jj_consume_token(BEGIN);
1410           label_6:
1411           while (true) {
1412             switch (jj_nt.kind) {
1413             case 5:
1414             case 16:
1415             case 17:
1416             case 21:
1417             case REPLACE:
1418             case DEFINER:
1419             case CURRENT_USER:
1420             case LANGUAGE:
1421             case INLINE:
1422             case ADD:
1423             case AGGREGATE:
1424             case ARRAY:
1425             case AT:
1426             case ATTRIBUTE:
1427             case AUTHID:
1428             case BEGIN:
1429             case BODY:
1430             case BULK:
1431             case BYTE:
1432             case CASCADE:
1433             case CASE:
1434             case CLOSE:
1435             case COALESCE:
1436             case COLLECT:
1437             case COLUMN:
1438             case COMMENT:
1439             case COMMIT:
1440             case CONSTRUCTOR:
1441             case CONTINUE:
1442             case CONVERT:
1443             case CURRENT:
1444             case CURSOR:
1445             case DATA:
1446             case DATE:
1447             case DAY:
1448             case DECLARE:
1449             case DELETE:
1450             case DISABLE:
1451             case EDITIONABLE:
1452             case ELEMENT:
1453             case ENABLE:
1454             case ESCAPE:
1455             case EXCEPT:
1456             case EXCEPTIONS:
1457             case EXECUTE:
1458             case EXIT:
1459             case EXTERNAL:
1460             case EXTENDS:
1461             case EXTRACT:
1462             case FALSE:
1463             case FETCH:
1464             case FINAL:
1465             case FOR:
1466             case FORALL:
1467             case FORCE:
1468             case FUNCTION:
1469             case GLOBAL:
1470             case GOTO:
1471             case HASH:
1472             case HEAP:
1473             case HOUR:
1474             case IF:
1475             case IMMEDIATE:
1476             case INDICES:
1477             case INDEXTYPE:
1478             case INDICATOR:
1479             case INSERT:
1480             case INSTANTIABLE:
1481             case INTERVAL:
1482             case INVALIDATE:
1483             case ISOLATION:
1484             case JAVA:
1485             case LEVEL:
1486             case LIMIT:
1487             case LOCK:
1488             case LOOP:
1489             case MAP:
1490             case MAX:
1491             case MEMBER:
1492             case MERGE:
1493             case MIN:
1494             case MINUTE:
1495             case MLSLABEL:
1496             case MODIFY:
1497             case MOD:
1498             case MONTH:
1499             case NATURAL:
1500             case NEW:
1501             case NEW_DOT:
1502             case NO:
1503             case NONEDITIONABLE:
1504             case NOT:
1505             case NULL:
1506             case NULLIF:
1507             case OBJECT:
1508             case OID:
1509             case OPAQUE:
1510             case OPEN:
1511             case OPERATOR:
1512             case ORGANIZATION:
1513             case OTHERS:
1514             case OVERRIDING:
1515             case PACKAGE:
1516             case PARTITION:
1517             case PIPE:
1518             case PRAGMA:
1519             case PRESERVE:
1520             case PRIVATE:
1521             case PROCEDURE:
1522             case RAISE:
1523             case RANGE:
1524             case RAW:
1525             case REAL:
1526             case RECORD:
1527             case REF:
1528             case RELEASE:
1529             case RELIES_ON:
1530             case RENAME:
1531             case RESULT:
1532             case RETURN:
1533             case RETURNING:
1534             case REVERSE:
1535             case ROLLBACK:
1536             case ROW:
1537             case ROWS:
1538             case ROWID:
1539             case ROWNUM:
1540             case SAVE:
1541             case SAVEPOINT:
1542             case SECOND:
1543             case SELECT:
1544             case SELF:
1545             case SET:
1546             case SPACE:
1547             case SQL:
1548             case SQLCODE:
1549             case SQLERRM:
1550             case STATIC:
1551             case SUBTYPE:
1552             case SUBSTITUTABLE:
1553             case SUCCESSFUL:
1554             case SYSDATE:
1555             case SYS_REFCURSOR:
1556             case TEMPORARY:
1557             case TIME:
1558             case TIMESTAMP:
1559             case TIMEZONE_REGION:
1560             case TIMEZONE_ABBR:
1561             case TIMEZONE_MINUTE:
1562             case TIMEZONE_HOUR:
1563             case TRANSACTION:
1564             case TRUE:
1565             case TYPE:
1566             case UNDER:
1567             case USING:
1568             case WHILE:
1569             case YES:
1570             case SHOW:
1571             case A:
1572             case UPDATE:
1573             case DOUBLE:
1574             case DEC:
1575             case PRECISION:
1576             case INT:
1577             case NUMERIC:
1578             case NCHAR:
1579             case NVARCHAR2:
1580             case STRING:
1581             case UROWID:
1582             case VARRAY:
1583             case VARYING:
1584             case BFILE:
1585             case BLOB:
1586             case CLOB:
1587             case NCLOB:
1588             case YEAR:
1589             case LOCAL:
1590             case WITH:
1591             case ZONE:
1592             case CHARACTER:
1593             case AFTER:
1594             case BEFORE:
1595             case OLD:
1596             case PARENT:
1597             case CC_IF:
1598             case CC_ERROR:
1599             case ANALYZE:
1600             case ASSOCIATE:
1601             case AUDIT:
1602             case COMPOUND:
1603             case DATABASE:
1604             case CALL:
1605             case DDL:
1606             case DISASSOCIATE:
1607             case EACH:
1608             case FOLLOWS:
1609             case LOGOFF:
1610             case LOGON:
1611             case NESTED:
1612             case NOAUDIT:
1613             case SCHEMA:
1614             case SERVERERROR:
1615             case SHUTDOWN:
1616             case STARTUP:
1617             case STATEMENT:
1618             case STATISTICS:
1619             case SUSPEND:
1620             case TRUNCATE:
1621             case WRAPPED:
1622             case LIBRARY:
1623             case NAME:
1624             case STRUCT:
1625             case CONTEXT:
1626             case PARAMETERS:
1627             case LENGTH:
1628             case TDO:
1629             case MAXLEN:
1630             case CHARSETID:
1631             case CHARSETFORM:
1632             case ACCEPT:
1633             case ACCESSIBLE:
1634             case COPY:
1635             case DEFINE:
1636             case DISCONNECT:
1637             case HOST:
1638             case PRINT:
1639             case QUIT:
1640             case REMARK:
1641             case UNDEFINE:
1642             case VARIABLE:
1643             case WHENEVER:
1644             case ATTACH:
1645             case CAST:
1646             case TREAT:
1647             case TRIM:
1648             case LEFT:
1649             case RIGHT:
1650             case BOTH:
1651             case EMPTY:
1652             case MULTISET:
1653             case SUBMULTISET:
1654             case LEADING:
1655             case TRAILING:
1656             case CHAR_CS:
1657             case NCHAR_CS:
1658             case DBTIMEZONE:
1659             case SESSIONTIMEZONE:
1660             case AUTHENTICATED:
1661             case LINK:
1662             case SHARED:
1663             case DIRECTORY:
1664             case USER:
1665             case IDENTIFIER:
1666             case UNSIGNED_NUMERIC_LITERAL:
1667             case CHARACTER_LITERAL:
1668             case STRING_LITERAL:
1669             case QUOTED_LITERAL:
1670               ;
1671               break;
1672             default:
1673               jj_la1[26] = jj_gen;
1674               break label_6;
1675             }
1676             Statement();
1677           }
1678           switch (jj_nt.kind) {
1679           case EXCEPTION:
1680             ExceptionHandler();
1681             break;
1682           default:
1683             jj_la1[27] = jj_gen;
1684             ;
1685           }
1686           break;
1687         default:
1688           jj_la1[28] = jj_gen;
1689           ;
1690         }
1691         jj_consume_token(END);
1692         switch (jj_nt.kind) {
1693         case REPLACE:
1694         case DEFINER:
1695         case CURRENT_USER:
1696         case SERIALLY_REUSABLE:
1697         case RESTRICT_REFERENCES:
1698         case EXCEPTION_INIT:
1699         case AUTONOMOUS_TRANSACTION:
1700         case LANGUAGE:
1701         case INLINE:
1702         case ADD:
1703         case AGGREGATE:
1704         case ALL:
1705         case ALTER:
1706         case AND:
1707         case ANY:
1708         case ARRAY:
1709         case AS:
1710         case ASC:
1711         case AT:
1712         case ATTRIBUTE:
1713         case AUTHID:
1714         case AVG:
1715         case BETWEEN:
1716         case BINARY_INTEGER:
1717         case BODY:
1718         case BOOLEAN:
1719         case BULK:
1720         case BY:
1721         case BYTE:
1722         case CASCADE:
1723         case CASE:
1724         case CHAR:
1725         case CHAR_BASE:
1726         case CHECK:
1727         case CLOSE:
1728         case CLUSTER:
1729         case COALESCE:
1730         case COLLECT:
1731         case COLUMN:
1732         case COMMENT:
1733         case COMMIT:
1734         case COMPRESS:
1735         case CONNECT:
1736         case CONSTANT:
1737         case CONSTRUCTOR:
1738         case CONTINUE:
1739         case CONVERT:
1740         case CREATE:
1741         case CURRENT:
1742         case CURRVAL:
1743         case CURSOR:
1744         case DATA:
1745         case DATE:
1746         case DAY:
1747         case DECLARE:
1748         case DECIMAL:
1749         case _DEFAULT:
1750         case DELETE:
1751         case DESC:
1752         case DISABLE:
1753         case DISTINCT:
1754         case DO:
1755         case DROP:
1756         case EDITIONABLE:
1757         case ELEMENT:
1758         case ELSE:
1759         case ELSIF:
1760         case ENABLE:
1761         case ESCAPE:
1762         case EXCEPT:
1763         case EXCEPTION:
1764         case EXCEPTIONS:
1765         case EXCLUSIVE:
1766         case EXECUTE:
1767         case EXISTS:
1768         case EXIT:
1769         case EXTERNAL:
1770         case EXTENDS:
1771         case EXTRACT:
1772         case FALSE:
1773         case FETCH:
1774         case FINAL:
1775         case FLOAT:
1776         case FOR:
1777         case FORALL:
1778         case FORCE:
1779         case FROM:
1780         case FUNCTION:
1781         case GLOBAL:
1782         case GOTO:
1783         case GROUP:
1784         case HASH:
1785         case HAVING:
1786         case HEAP:
1787         case HOUR:
1788         case IF:
1789         case IMMEDIATE:
1790         case IN:
1791         case INDEX:
1792         case INDICES:
1793         case INDEXTYPE:
1794         case INDICATOR:
1795         case INSERT:
1796         case INSTANTIABLE:
1797         case INTEGER:
1798         case INTERFACE:
1799         case INTERSECT:
1800         case INTERVAL:
1801         case INTO:
1802         case INVALIDATE:
1803         case IS:
1804         case ISOLATION:
1805         case JAVA:
1806         case LEVEL:
1807         case LIKE:
1808         case LIMIT:
1809         case LIMITED:
1810         case LOCK:
1811         case LONG:
1812         case LOOP:
1813         case MAP:
1814         case MAX:
1815         case MEMBER:
1816         case MERGE:
1817         case MIN:
1818         case MINUS:
1819         case MINUTE:
1820         case MLSLABEL:
1821         case MODIFY:
1822         case MOD:
1823         case MODE:
1824         case MONTH:
1825         case NATURAL:
1826         case NATURALN:
1827         case NEW:
1828         case NEXTVAL:
1829         case NO:
1830         case NOCOPY:
1831         case NONEDITIONABLE:
1832         case NOT:
1833         case NOWAIT:
1834         case NULL:
1835         case NULLIF:
1836         case NUMBER:
1837         case BFILE_BASE:
1838         case BLOB_BASE:
1839         case CLOB_BASE:
1840         case DATE_BASE:
1841         case NUMBER_BASE:
1842         case OBJECT:
1843         case OCIROWID:
1844         case OF:
1845         case OID:
1846         case ON:
1847         case OPAQUE:
1848         case OPEN:
1849         case OPERATOR:
1850         case OPTION:
1851         case OR:
1852         case ORDER:
1853         case ORGANIZATION:
1854         case OTHERS:
1855         case OUT:
1856         case OVERRIDING:
1857         case PACKAGE:
1858         case PARTITION:
1859         case PCTFREE:
1860         case PLS_INTEGER:
1861         case POSITIVE:
1862         case POSITIVEN:
1863         case PRESERVE:
1864         case PRIOR:
1865         case PROMPT:
1866         case PRIVATE:
1867         case PROCEDURE:
1868         case PUBLIC:
1869         case RAISE:
1870         case RANGE:
1871         case RAW:
1872         case REAL:
1873         case RECORD:
1874         case REF:
1875         case RELEASE:
1876         case RELIES_ON:
1877         case RENAME:
1878         case RESULT:
1879         case RETURN:
1880         case RETURNING:
1881         case REVERSE:
1882         case ROLLBACK:
1883         case ROW:
1884         case ROWS:
1885         case ROWID:
1886         case ROWNUM:
1887         case ROWTYPE:
1888         case SAVE:
1889         case SAVEPOINT:
1890         case SECOND:
1891         case SELECT:
1892         case SELF:
1893         case SEPARATE:
1894         case SET:
1895         case SHARE:
1896         case SMALLINT:
1897         case SPACE:
1898         case SQL:
1899         case SQLCODE:
1900         case SQLERRM:
1901         case START:
1902         case STATIC:
1903         case STDDEV:
1904         case SUBTYPE:
1905         case SUBSTITUTABLE:
1906         case SUCCESSFUL:
1907         case SUM:
1908         case SYNONYM:
1909         case SYSDATE:
1910         case SYS_REFCURSOR:
1911         case TABLE:
1912         case TEMPORARY:
1913         case THEN:
1914         case TIME:
1915         case TIMESTAMP:
1916         case TIMEZONE_REGION:
1917         case TIMEZONE_ABBR:
1918         case TIMEZONE_MINUTE:
1919         case TIMEZONE_HOUR:
1920         case TO:
1921         case TRANSACTION:
1922         case TRIGGER:
1923         case TRUE:
1924         case TYPE:
1925         case UI:
1926         case UNDER:
1927         case USING:
1928         case WHILE:
1929         case YES:
1930         case SHOW:
1931         case A:
1932         case UPDATE:
1933         case VARCHAR:
1934         case VARCHAR2:
1935         case DOUBLE:
1936         case DEC:
1937         case PRECISION:
1938         case INT:
1939         case NUMERIC:
1940         case SIGNTYPE:
1941         case NCHAR:
1942         case NVARCHAR2:
1943         case STRING:
1944         case UROWID:
1945         case VARRAY:
1946         case VARYING:
1947         case BFILE:
1948         case BLOB:
1949         case CLOB:
1950         case NCLOB:
1951         case YEAR:
1952         case LOCAL:
1953         case WITH:
1954         case ZONE:
1955         case CHARACTER:
1956         case AFTER:
1957         case BEFORE:
1958         case OLD:
1959         case PARENT:
1960         case ANALYZE:
1961         case ASSOCIATE:
1962         case AUDIT:
1963         case COMPOUND:
1964         case DATABASE:
1965         case CALL:
1966         case DDL:
1967         case DISASSOCIATE:
1968         case EACH:
1969         case FOLLOWS:
1970         case LOGOFF:
1971         case LOGON:
1972         case NESTED:
1973         case NOAUDIT:
1974         case SCHEMA:
1975         case SERVERERROR:
1976         case SHUTDOWN:
1977         case STARTUP:
1978         case STATEMENT:
1979         case STATISTICS:
1980         case SUSPEND:
1981         case TRUNCATE:
1982         case WRAPPED:
1983         case LIBRARY:
1984         case NAME:
1985         case STRUCT:
1986         case CONTEXT:
1987         case PARAMETERS:
1988         case LENGTH:
1989         case TDO:
1990         case MAXLEN:
1991         case CHARSETID:
1992         case CHARSETFORM:
1993         case ACCEPT:
1994         case ACCESSIBLE:
1995         case COPY:
1996         case DEFINE:
1997         case DISCONNECT:
1998         case HOST:
1999         case PRINT:
2000         case QUIT:
2001         case REMARK:
2002         case UNDEFINE:
2003         case VARIABLE:
2004         case WHENEVER:
2005         case ATTACH:
2006         case CAST:
2007         case TREAT:
2008         case TRIM:
2009         case LEFT:
2010         case RIGHT:
2011         case BOTH:
2012         case EMPTY:
2013         case MULTISET:
2014         case SUBMULTISET:
2015         case LEADING:
2016         case TRAILING:
2017         case CHAR_CS:
2018         case NCHAR_CS:
2019         case DBTIMEZONE:
2020         case SESSIONTIMEZONE:
2021         case AUTHENTICATED:
2022         case LINK:
2023         case SHARED:
2024         case DIRECTORY:
2025         case USER:
2026         case IDENTIFIER:
2027         case QUOTED_LITERAL:
2028         case SQLDATA_CLASS:
2029         case CUSTOMDATUM_CLASS:
2030         case ORADATA_CLASS:
2031         case JAVA_INTERFACE_CLASS:
2032           ID();
2033           break;
2034         default:
2035           jj_la1[29] = jj_gen;
2036           ;
2037         }
2038         jj_consume_token(4);
2039         break;
2040       default:
2041         jj_la1[30] = jj_gen;
2042         jj_consume_token(-1);
2043         throw new ParseException();
2044       }
2045       jjtree.closeNodeScope(jjtn000, true);
2046       jjtc000 = false;
2047       jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
2048     } catch (Throwable jjte000) {
2049       if (jjtc000) {
2050         jjtree.clearNodeScope(jjtn000);
2051         jjtc000 = false;
2052       } else {
2053         jjtree.popNode();
2054       }
2055       if (jjte000 instanceof RuntimeException) {
2056         {if (true) throw (RuntimeException)jjte000;}
2057       }
2058       if (jjte000 instanceof ParseException) {
2059         {if (true) throw (ParseException)jjte000;}
2060       }
2061       {if (true) throw (Error)jjte000;}
2062     } finally {
2063       if (jjtc000) {
2064         jjtree.closeNodeScope(jjtn000, true);
2065       }
2066     }
2067     throw new Error("Missing return statement in function");
2068   }
2069 
2070   final public ASTDeclarativeUnit DeclarativeUnit() throws ParseException {
2071  /*@bgen(jjtree) DeclarativeUnit */
2072   ASTDeclarativeUnit jjtn000 = new ASTDeclarativeUnit(this, JJTDECLARATIVEUNIT);
2073   boolean jjtc000 = true;
2074   jjtree.openNodeScope(jjtn000);
2075     try {
2076       switch (jj_nt.kind) {
2077       case PRAGMA:
2078         Pragma();
2079         break;
2080       default:
2081         jj_la1[31] = jj_gen;
2082         if (jj_2_16(2)) {
2083           ExceptionDeclaration();
2084         } else if (jj_2_17(2147483647)) {
2085           SubTypeDefinition();
2086         } else if (jj_2_18(2147483647)) {
2087           ProgramUnit();
2088         } else if (jj_2_19(4)) {
2089           VariableOrConstantDeclaration();
2090         } else if (jj_2_20(2)) {
2091           CursorSpecification();
2092         } else {
2093           switch (jj_nt.kind) {
2094           case CURSOR:
2095             CursorBody();
2096             break;
2097           case IDENTIFIER:
2098             CollectionDeclaration();
2099             break;
2100           case CONSTRUCTOR:
2101           case CREATE:
2102           case FINAL:
2103           case FUNCTION:
2104           case INSTANTIABLE:
2105           case MAP:
2106           case MEMBER:
2107           case NOT:
2108           case ORDER:
2109           case OVERRIDING:
2110           case PROCEDURE:
2111           case STATIC:
2112             MethodDeclaration();
2113             break;
2114           case CC_IF:
2115             CompilationDeclarationFragment();
2116             break;
2117           default:
2118             jj_la1[32] = jj_gen;
2119             jj_consume_token(-1);
2120             throw new ParseException();
2121           }
2122         }
2123       }
2124       jjtree.closeNodeScope(jjtn000, true);
2125       jjtc000 = false;
2126       {if (true) return jjtn000 ;}
2127     } catch (Throwable jjte000) {
2128       if (jjtc000) {
2129         jjtree.clearNodeScope(jjtn000);
2130         jjtc000 = false;
2131       } else {
2132         jjtree.popNode();
2133       }
2134       if (jjte000 instanceof RuntimeException) {
2135         {if (true) throw (RuntimeException)jjte000;}
2136       }
2137       if (jjte000 instanceof ParseException) {
2138         {if (true) throw (ParseException)jjte000;}
2139       }
2140       {if (true) throw (Error)jjte000;}
2141     } finally {
2142       if (jjtc000) {
2143         jjtree.closeNodeScope(jjtn000, true);
2144       }
2145     }
2146     throw new Error("Missing return statement in function");
2147   }
2148 
2149   final public ASTDeclarativeSection DeclarativeSection() throws ParseException {
2150  /*@bgen(jjtree) DeclarativeSection */
2151   ASTDeclarativeSection jjtn000 = new ASTDeclarativeSection(this, JJTDECLARATIVESECTION);
2152   boolean jjtc000 = true;
2153   jjtree.openNodeScope(jjtn000);
2154     try {
2155       label_7:
2156       while (true) {
2157         switch (jj_nt.kind) {
2158         case REPLACE:
2159         case DEFINER:
2160         case CURRENT_USER:
2161         case SERIALLY_REUSABLE:
2162         case RESTRICT_REFERENCES:
2163         case EXCEPTION_INIT:
2164         case AUTONOMOUS_TRANSACTION:
2165         case LANGUAGE:
2166         case INLINE:
2167         case ADD:
2168         case AGGREGATE:
2169         case ALL:
2170         case ALTER:
2171         case AND:
2172         case ANY:
2173         case ARRAY:
2174         case AS:
2175         case ASC:
2176         case AT:
2177         case ATTRIBUTE:
2178         case AUTHID:
2179         case AVG:
2180         case BETWEEN:
2181         case BINARY_INTEGER:
2182         case BODY:
2183         case BOOLEAN:
2184         case BULK:
2185         case BY:
2186         case BYTE:
2187         case CASCADE:
2188         case CASE:
2189         case CHAR:
2190         case CHAR_BASE:
2191         case CHECK:
2192         case CLOSE:
2193         case CLUSTER:
2194         case COALESCE:
2195         case COLLECT:
2196         case COLUMN:
2197         case COMMENT:
2198         case COMMIT:
2199         case COMPRESS:
2200         case CONNECT:
2201         case CONSTANT:
2202         case CONSTRUCTOR:
2203         case CONTINUE:
2204         case CONVERT:
2205         case CREATE:
2206         case CURRENT:
2207         case CURRVAL:
2208         case CURSOR:
2209         case DATA:
2210         case DATE:
2211         case DAY:
2212         case DECLARE:
2213         case DECIMAL:
2214         case _DEFAULT:
2215         case DELETE:
2216         case DESC:
2217         case DISABLE:
2218         case DISTINCT:
2219         case DO:
2220         case DROP:
2221         case EDITIONABLE:
2222         case ELEMENT:
2223         case ELSE:
2224         case ELSIF:
2225         case ENABLE:
2226         case ESCAPE:
2227         case EXCEPT:
2228         case EXCEPTION:
2229         case EXCEPTIONS:
2230         case EXCLUSIVE:
2231         case EXECUTE:
2232         case EXISTS:
2233         case EXIT:
2234         case EXTERNAL:
2235         case EXTENDS:
2236         case EXTRACT:
2237         case FALSE:
2238         case FETCH:
2239         case FINAL:
2240         case FLOAT:
2241         case FOR:
2242         case FORALL:
2243         case FORCE:
2244         case FROM:
2245         case FUNCTION:
2246         case GLOBAL:
2247         case GOTO:
2248         case GROUP:
2249         case HASH:
2250         case HAVING:
2251         case HEAP:
2252         case HOUR:
2253         case IF:
2254         case IMMEDIATE:
2255         case IN:
2256         case INDEX:
2257         case INDICES:
2258         case INDEXTYPE:
2259         case INDICATOR:
2260         case INSERT:
2261         case INSTANTIABLE:
2262         case INTEGER:
2263         case INTERFACE:
2264         case INTERSECT:
2265         case INTERVAL:
2266         case INTO:
2267         case INVALIDATE:
2268         case IS:
2269         case ISOLATION:
2270         case JAVA:
2271         case LEVEL:
2272         case LIKE:
2273         case LIMIT:
2274         case LIMITED:
2275         case LOCK:
2276         case LONG:
2277         case LOOP:
2278         case MAP:
2279         case MAX:
2280         case MEMBER:
2281         case MERGE:
2282         case MIN:
2283         case MINUS:
2284         case MINUTE:
2285         case MLSLABEL:
2286         case MODIFY:
2287         case MOD:
2288         case MODE:
2289         case MONTH:
2290         case NATURAL:
2291         case NATURALN:
2292         case NEW:
2293         case NEXTVAL:
2294         case NO:
2295         case NOCOPY:
2296         case NONEDITIONABLE:
2297         case NOT:
2298         case NOWAIT:
2299         case NULL:
2300         case NULLIF:
2301         case NUMBER:
2302         case BFILE_BASE:
2303         case BLOB_BASE:
2304         case CLOB_BASE:
2305         case DATE_BASE:
2306         case NUMBER_BASE:
2307         case OBJECT:
2308         case OCIROWID:
2309         case OF:
2310         case OID:
2311         case ON:
2312         case OPAQUE:
2313         case OPEN:
2314         case OPERATOR:
2315         case OPTION:
2316         case OR:
2317         case ORDER:
2318         case ORGANIZATION:
2319         case OTHERS:
2320         case OUT:
2321         case OVERRIDING:
2322         case PACKAGE:
2323         case PARTITION:
2324         case PCTFREE:
2325         case PLS_INTEGER:
2326         case POSITIVE:
2327         case POSITIVEN:
2328         case PRAGMA:
2329         case PRESERVE:
2330         case PRIOR:
2331         case PROMPT:
2332         case PRIVATE:
2333         case PROCEDURE:
2334         case PUBLIC:
2335         case RAISE:
2336         case RANGE:
2337         case RAW:
2338         case REAL:
2339         case RECORD:
2340         case REF:
2341         case RELEASE:
2342         case RELIES_ON:
2343         case RENAME:
2344         case RESULT:
2345         case RETURN:
2346         case RETURNING:
2347         case REVERSE:
2348         case ROLLBACK:
2349         case ROW:
2350         case ROWS:
2351         case ROWID:
2352         case ROWNUM:
2353         case ROWTYPE:
2354         case SAVE:
2355         case SAVEPOINT:
2356         case SECOND:
2357         case SELECT:
2358         case SELF:
2359         case SEPARATE:
2360         case SET:
2361         case SHARE:
2362         case SMALLINT:
2363         case SPACE:
2364         case SQL:
2365         case SQLCODE:
2366         case SQLERRM:
2367         case START:
2368         case STATIC:
2369         case STDDEV:
2370         case SUBTYPE:
2371         case SUBSTITUTABLE:
2372         case SUCCESSFUL:
2373         case SUM:
2374         case SYNONYM:
2375         case SYSDATE:
2376         case SYS_REFCURSOR:
2377         case TABLE:
2378         case TEMPORARY:
2379         case THEN:
2380         case TIME:
2381         case TIMESTAMP:
2382         case TIMEZONE_REGION:
2383         case TIMEZONE_ABBR:
2384         case TIMEZONE_MINUTE:
2385         case TIMEZONE_HOUR:
2386         case TO:
2387         case TRANSACTION:
2388         case TRIGGER:
2389         case TRUE:
2390         case TYPE:
2391         case UI:
2392         case UNDER:
2393         case USING:
2394         case WHILE:
2395         case YES:
2396         case SHOW:
2397         case A:
2398         case UPDATE:
2399         case VARCHAR:
2400         case VARCHAR2:
2401         case DOUBLE:
2402         case DEC:
2403         case PRECISION:
2404         case INT:
2405         case NUMERIC:
2406         case SIGNTYPE:
2407         case NCHAR:
2408         case NVARCHAR2:
2409         case STRING:
2410         case UROWID:
2411         case VARRAY:
2412         case VARYING:
2413         case BFILE:
2414         case BLOB:
2415         case CLOB:
2416         case NCLOB:
2417         case YEAR:
2418         case LOCAL:
2419         case WITH:
2420         case ZONE:
2421         case CHARACTER:
2422         case AFTER:
2423         case BEFORE:
2424         case OLD:
2425         case PARENT:
2426         case CC_IF:
2427         case ANALYZE:
2428         case ASSOCIATE:
2429         case AUDIT:
2430         case COMPOUND:
2431         case DATABASE:
2432         case CALL:
2433         case DDL:
2434         case DISASSOCIATE:
2435         case EACH:
2436         case FOLLOWS:
2437         case LOGOFF:
2438         case LOGON:
2439         case NESTED:
2440         case NOAUDIT:
2441         case SCHEMA:
2442         case SERVERERROR:
2443         case SHUTDOWN:
2444         case STARTUP:
2445         case STATEMENT:
2446         case STATISTICS:
2447         case SUSPEND:
2448         case TRUNCATE:
2449         case WRAPPED:
2450         case LIBRARY:
2451         case NAME:
2452         case STRUCT:
2453         case CONTEXT:
2454         case PARAMETERS:
2455         case LENGTH:
2456         case TDO:
2457         case MAXLEN:
2458         case CHARSETID:
2459         case CHARSETFORM:
2460         case ACCEPT:
2461         case ACCESSIBLE:
2462         case COPY:
2463         case DEFINE:
2464         case DISCONNECT:
2465         case HOST:
2466         case PRINT:
2467         case QUIT:
2468         case REMARK:
2469         case UNDEFINE:
2470         case VARIABLE:
2471         case WHENEVER:
2472         case ATTACH:
2473         case CAST:
2474         case TREAT:
2475         case TRIM:
2476         case LEFT:
2477         case RIGHT:
2478         case BOTH:
2479         case EMPTY:
2480         case MULTISET:
2481         case SUBMULTISET:
2482         case LEADING:
2483         case TRAILING:
2484         case CHAR_CS:
2485         case NCHAR_CS:
2486         case DBTIMEZONE:
2487         case SESSIONTIMEZONE:
2488         case AUTHENTICATED:
2489         case LINK:
2490         case SHARED:
2491         case DIRECTORY:
2492         case USER:
2493         case IDENTIFIER:
2494         case QUOTED_LITERAL:
2495         case SQLDATA_CLASS:
2496         case CUSTOMDATUM_CLASS:
2497         case ORADATA_CLASS:
2498         case JAVA_INTERFACE_CLASS:
2499           ;
2500           break;
2501         default:
2502           jj_la1[33] = jj_gen;
2503           break label_7;
2504         }
2505         DeclarativeUnit();
2506       }
2507         jjtree.closeNodeScope(jjtn000, true);
2508         jjtc000 = false;
2509         {if (true) return jjtn000 ;}
2510     } catch (Throwable jjte000) {
2511           if (jjtc000) {
2512             jjtree.clearNodeScope(jjtn000);
2513             jjtc000 = false;
2514           } else {
2515             jjtree.popNode();
2516           }
2517           if (jjte000 instanceof RuntimeException) {
2518             {if (true) throw (RuntimeException)jjte000;}
2519           }
2520           if (jjte000 instanceof ParseException) {
2521             {if (true) throw (ParseException)jjte000;}
2522           }
2523           {if (true) throw (Error)jjte000;}
2524     } finally {
2525           if (jjtc000) {
2526             jjtree.closeNodeScope(jjtn000, true);
2527           }
2528     }
2529     throw new Error("Missing return statement in function");
2530   }
2531 
2532   final public ASTCompilationDeclarationFragment CompilationDeclarationFragment() throws ParseException {
2533  /*@bgen(jjtree) CompilationDeclarationFragment */
2534   ASTCompilationDeclarationFragment jjtn000 = new ASTCompilationDeclarationFragment(this, JJTCOMPILATIONDECLARATIONFRAGMENT);
2535   boolean jjtc000 = true;
2536   jjtree.openNodeScope(jjtn000);
2537     try {
2538       jj_consume_token(CC_IF);
2539       ConditionalOrExpression();
2540       jj_consume_token(CC_THEN);
2541       label_8:
2542       while (true) {
2543         switch (jj_nt.kind) {
2544         case REPLACE:
2545         case DEFINER:
2546         case CURRENT_USER:
2547         case SERIALLY_REUSABLE:
2548         case RESTRICT_REFERENCES:
2549         case EXCEPTION_INIT:
2550         case AUTONOMOUS_TRANSACTION:
2551         case LANGUAGE:
2552         case INLINE:
2553         case ADD:
2554         case AGGREGATE:
2555         case ALL:
2556         case ALTER:
2557         case AND:
2558         case ANY:
2559         case ARRAY:
2560         case AS:
2561         case ASC:
2562         case AT:
2563         case ATTRIBUTE:
2564         case AUTHID:
2565         case AVG:
2566         case BETWEEN:
2567         case BINARY_INTEGER:
2568         case BODY:
2569         case BOOLEAN:
2570         case BULK:
2571         case BY:
2572         case BYTE:
2573         case CASCADE:
2574         case CASE:
2575         case CHAR:
2576         case CHAR_BASE:
2577         case CHECK:
2578         case CLOSE:
2579         case CLUSTER:
2580         case COALESCE:
2581         case COLLECT:
2582         case COLUMN:
2583         case COMMENT:
2584         case COMMIT:
2585         case COMPRESS:
2586         case CONNECT:
2587         case CONSTANT:
2588         case CONSTRUCTOR:
2589         case CONTINUE:
2590         case CONVERT:
2591         case CREATE:
2592         case CURRENT:
2593         case CURRVAL:
2594         case CURSOR:
2595         case DATA:
2596         case DATE:
2597         case DAY:
2598         case DECLARE:
2599         case DECIMAL:
2600         case _DEFAULT:
2601         case DELETE:
2602         case DESC:
2603         case DISABLE:
2604         case DISTINCT:
2605         case DO:
2606         case DROP:
2607         case EDITIONABLE:
2608         case ELEMENT:
2609         case ELSE:
2610         case ELSIF:
2611         case ENABLE:
2612         case ESCAPE:
2613         case EXCEPT:
2614         case EXCEPTION:
2615         case EXCEPTIONS:
2616         case EXCLUSIVE:
2617         case EXECUTE:
2618         case EXISTS:
2619         case EXIT:
2620         case EXTERNAL:
2621         case EXTENDS:
2622         case EXTRACT:
2623         case FALSE:
2624         case FETCH:
2625         case FINAL:
2626         case FLOAT:
2627         case FOR:
2628         case FORALL:
2629         case FORCE:
2630         case FROM:
2631         case FUNCTION:
2632         case GLOBAL:
2633         case GOTO:
2634         case GROUP:
2635         case HASH:
2636         case HAVING:
2637         case HEAP:
2638         case HOUR:
2639         case IF:
2640         case IMMEDIATE:
2641         case IN:
2642         case INDEX:
2643         case INDICES:
2644         case INDEXTYPE:
2645         case INDICATOR:
2646         case INSERT:
2647         case INSTANTIABLE:
2648         case INTEGER:
2649         case INTERFACE:
2650         case INTERSECT:
2651         case INTERVAL:
2652         case INTO:
2653         case INVALIDATE:
2654         case IS:
2655         case ISOLATION:
2656         case JAVA:
2657         case LEVEL:
2658         case LIKE:
2659         case LIMIT:
2660         case LIMITED:
2661         case LOCK:
2662         case LONG:
2663         case LOOP:
2664         case MAP:
2665         case MAX:
2666         case MEMBER:
2667         case MERGE:
2668         case MIN:
2669         case MINUS:
2670         case MINUTE:
2671         case MLSLABEL:
2672         case MODIFY:
2673         case MOD:
2674         case MODE:
2675         case MONTH:
2676         case NATURAL:
2677         case NATURALN:
2678         case NEW:
2679         case NEXTVAL:
2680         case NO:
2681         case NOCOPY:
2682         case NONEDITIONABLE:
2683         case NOT:
2684         case NOWAIT:
2685         case NULL:
2686         case NULLIF:
2687         case NUMBER:
2688         case BFILE_BASE:
2689         case BLOB_BASE:
2690         case CLOB_BASE:
2691         case DATE_BASE:
2692         case NUMBER_BASE:
2693         case OBJECT:
2694         case OCIROWID:
2695         case OF:
2696         case OID:
2697         case ON:
2698         case OPAQUE:
2699         case OPEN:
2700         case OPERATOR:
2701         case OPTION:
2702         case OR:
2703         case ORDER:
2704         case ORGANIZATION:
2705         case OTHERS:
2706         case OUT:
2707         case OVERRIDING:
2708         case PACKAGE:
2709         case PARTITION:
2710         case PCTFREE:
2711         case PLS_INTEGER:
2712         case POSITIVE:
2713         case POSITIVEN:
2714         case PRAGMA:
2715         case PRESERVE:
2716         case PRIOR:
2717         case PROMPT:
2718         case PRIVATE:
2719         case PROCEDURE:
2720         case PUBLIC:
2721         case RAISE:
2722         case RANGE:
2723         case RAW:
2724         case REAL:
2725         case RECORD:
2726         case REF:
2727         case RELEASE:
2728         case RELIES_ON:
2729         case RENAME:
2730         case RESULT:
2731         case RETURN:
2732         case RETURNING:
2733         case REVERSE:
2734         case ROLLBACK:
2735         case ROW:
2736         case ROWS:
2737         case ROWID:
2738         case ROWNUM:
2739         case ROWTYPE:
2740         case SAVE:
2741         case SAVEPOINT:
2742         case SECOND:
2743         case SELECT:
2744         case SELF:
2745         case SEPARATE:
2746         case SET:
2747         case SHARE:
2748         case SMALLINT:
2749         case SPACE:
2750         case SQL:
2751         case SQLCODE:
2752         case SQLERRM:
2753         case START:
2754         case STATIC:
2755         case STDDEV:
2756         case SUBTYPE:
2757         case SUBSTITUTABLE:
2758         case SUCCESSFUL:
2759         case SUM:
2760         case SYNONYM:
2761         case SYSDATE:
2762         case SYS_REFCURSOR:
2763         case TABLE:
2764         case TEMPORARY:
2765         case THEN:
2766         case TIME:
2767         case TIMESTAMP:
2768         case TIMEZONE_REGION:
2769         case TIMEZONE_ABBR:
2770         case TIMEZONE_MINUTE:
2771         case TIMEZONE_HOUR:
2772         case TO:
2773         case TRANSACTION:
2774         case TRIGGER:
2775         case TRUE:
2776         case TYPE:
2777         case UI:
2778         case UNDER:
2779         case USING:
2780         case WHILE:
2781         case YES:
2782         case SHOW:
2783         case A:
2784         case UPDATE:
2785         case VARCHAR:
2786         case VARCHAR2:
2787         case DOUBLE:
2788         case DEC:
2789         case PRECISION:
2790         case INT:
2791         case NUMERIC:
2792         case SIGNTYPE:
2793         case NCHAR:
2794         case NVARCHAR2:
2795         case STRING:
2796         case UROWID:
2797         case VARRAY:
2798         case VARYING:
2799         case BFILE:
2800         case BLOB:
2801         case CLOB:
2802         case NCLOB:
2803         case YEAR:
2804         case LOCAL:
2805         case WITH:
2806         case ZONE:
2807         case CHARACTER:
2808         case AFTER:
2809         case BEFORE:
2810         case OLD:
2811         case PARENT:
2812         case CC_IF:
2813         case CC_ERROR:
2814         case ANALYZE:
2815         case ASSOCIATE:
2816         case AUDIT:
2817         case COMPOUND:
2818         case DATABASE:
2819         case CALL:
2820         case DDL:
2821         case DISASSOCIATE:
2822         case EACH:
2823         case FOLLOWS:
2824         case LOGOFF:
2825         case LOGON:
2826         case NESTED:
2827         case NOAUDIT:
2828         case SCHEMA:
2829         case SERVERERROR:
2830         case SHUTDOWN:
2831         case STARTUP:
2832         case STATEMENT:
2833         case STATISTICS:
2834         case SUSPEND:
2835         case TRUNCATE:
2836         case WRAPPED:
2837         case LIBRARY:
2838         case NAME:
2839         case STRUCT:
2840         case CONTEXT:
2841         case PARAMETERS:
2842         case LENGTH:
2843         case TDO:
2844         case MAXLEN:
2845         case CHARSETID:
2846         case CHARSETFORM:
2847         case ACCEPT:
2848         case ACCESSIBLE:
2849         case COPY:
2850         case DEFINE:
2851         case DISCONNECT:
2852         case HOST:
2853         case PRINT:
2854         case QUIT:
2855         case REMARK:
2856         case UNDEFINE:
2857         case VARIABLE:
2858         case WHENEVER:
2859         case ATTACH:
2860         case CAST:
2861         case TREAT:
2862         case TRIM:
2863         case LEFT:
2864         case RIGHT:
2865         case BOTH:
2866         case EMPTY:
2867         case MULTISET:
2868         case SUBMULTISET:
2869         case LEADING:
2870         case TRAILING:
2871         case CHAR_CS:
2872         case NCHAR_CS:
2873         case DBTIMEZONE:
2874         case SESSIONTIMEZONE:
2875         case AUTHENTICATED:
2876         case LINK:
2877         case SHARED:
2878         case DIRECTORY:
2879         case USER:
2880         case IDENTIFIER:
2881         case QUOTED_LITERAL:
2882         case SQLDATA_CLASS:
2883         case CUSTOMDATUM_CLASS:
2884         case ORADATA_CLASS:
2885         case JAVA_INTERFACE_CLASS:
2886           ;
2887           break;
2888         default:
2889           jj_la1[34] = jj_gen;
2890           break label_8;
2891         }
2892         switch (jj_nt.kind) {
2893         case REPLACE:
2894         case DEFINER:
2895         case CURRENT_USER:
2896         case SERIALLY_REUSABLE:
2897         case RESTRICT_REFERENCES:
2898         case EXCEPTION_INIT:
2899         case AUTONOMOUS_TRANSACTION:
2900         case LANGUAGE:
2901         case INLINE:
2902         case ADD:
2903         case AGGREGATE:
2904         case ALL:
2905         case ALTER:
2906         case AND:
2907         case ANY:
2908         case ARRAY:
2909         case AS:
2910         case ASC:
2911         case AT:
2912         case ATTRIBUTE:
2913         case AUTHID:
2914         case AVG:
2915         case BETWEEN:
2916         case BINARY_INTEGER:
2917         case BODY:
2918         case BOOLEAN:
2919         case BULK:
2920         case BY:
2921         case BYTE:
2922         case CASCADE:
2923         case CASE:
2924         case CHAR:
2925         case CHAR_BASE:
2926         case CHECK:
2927         case CLOSE:
2928         case CLUSTER:
2929         case COALESCE:
2930         case COLLECT:
2931         case COLUMN:
2932         case COMMENT:
2933         case COMMIT:
2934         case COMPRESS:
2935         case CONNECT:
2936         case CONSTANT:
2937         case CONSTRUCTOR:
2938         case CONTINUE:
2939         case CONVERT:
2940         case CREATE:
2941         case CURRENT:
2942         case CURRVAL:
2943         case CURSOR:
2944         case DATA:
2945         case DATE:
2946         case DAY:
2947         case DECLARE:
2948         case DECIMAL:
2949         case _DEFAULT:
2950         case DELETE:
2951         case DESC:
2952         case DISABLE:
2953         case DISTINCT:
2954         case DO:
2955         case DROP:
2956         case EDITIONABLE:
2957         case ELEMENT:
2958         case ELSE:
2959         case ELSIF:
2960         case ENABLE:
2961         case ESCAPE:
2962         case EXCEPT:
2963         case EXCEPTION:
2964         case EXCEPTIONS:
2965         case EXCLUSIVE:
2966         case EXECUTE:
2967         case EXISTS:
2968         case EXIT:
2969         case EXTERNAL:
2970         case EXTENDS:
2971         case EXTRACT:
2972         case FALSE:
2973         case FETCH:
2974         case FINAL:
2975         case FLOAT:
2976         case FOR:
2977         case FORALL:
2978         case FORCE:
2979         case FROM:
2980         case FUNCTION:
2981         case GLOBAL:
2982         case GOTO:
2983         case GROUP:
2984         case HASH:
2985         case HAVING:
2986         case HEAP:
2987         case HOUR:
2988         case IF:
2989         case IMMEDIATE:
2990         case IN:
2991         case INDEX:
2992         case INDICES:
2993         case INDEXTYPE:
2994         case INDICATOR:
2995         case INSERT:
2996         case INSTANTIABLE:
2997         case INTEGER:
2998         case INTERFACE:
2999         case INTERSECT:
3000         case INTERVAL:
3001         case INTO:
3002         case INVALIDATE:
3003         case IS:
3004         case ISOLATION:
3005         case JAVA:
3006         case LEVEL:
3007         case LIKE:
3008         case LIMIT:
3009         case LIMITED:
3010         case LOCK:
3011         case LONG:
3012         case LOOP:
3013         case MAP:
3014         case MAX:
3015         case MEMBER:
3016         case MERGE:
3017         case MIN:
3018         case MINUS:
3019         case MINUTE:
3020         case MLSLABEL:
3021         case MODIFY:
3022         case MOD:
3023         case MODE:
3024         case MONTH:
3025         case NATURAL:
3026         case NATURALN:
3027         case NEW:
3028         case NEXTVAL:
3029         case NO:
3030         case NOCOPY:
3031         case NONEDITIONABLE:
3032         case NOT:
3033         case NOWAIT:
3034         case NULL:
3035         case NULLIF:
3036         case NUMBER:
3037         case BFILE_BASE:
3038         case BLOB_BASE:
3039         case CLOB_BASE:
3040         case DATE_BASE:
3041         case NUMBER_BASE:
3042         case OBJECT:
3043         case OCIROWID:
3044         case OF:
3045         case OID:
3046         case ON:
3047         case OPAQUE:
3048         case OPEN:
3049         case OPERATOR:
3050         case OPTION:
3051         case OR:
3052         case ORDER:
3053         case ORGANIZATION:
3054         case OTHERS:
3055         case OUT:
3056         case OVERRIDING:
3057         case PACKAGE:
3058         case PARTITION:
3059         case PCTFREE:
3060         case PLS_INTEGER:
3061         case POSITIVE:
3062         case POSITIVEN:
3063         case PRAGMA:
3064         case PRESERVE:
3065         case PRIOR:
3066         case PROMPT:
3067         case PRIVATE:
3068         case PROCEDURE:
3069         case PUBLIC:
3070         case RAISE:
3071         case RANGE:
3072         case RAW:
3073         case REAL:
3074         case RECORD:
3075         case REF:
3076         case RELEASE:
3077         case RELIES_ON:
3078         case RENAME:
3079         case RESULT:
3080         case RETURN:
3081         case RETURNING:
3082         case REVERSE:
3083         case ROLLBACK:
3084         case ROW:
3085         case ROWS:
3086         case ROWID:
3087         case ROWNUM:
3088         case ROWTYPE:
3089         case SAVE:
3090         case SAVEPOINT:
3091         case SECOND:
3092         case SELECT:
3093         case SELF:
3094         case SEPARATE:
3095         case SET:
3096         case SHARE:
3097         case SMALLINT:
3098         case SPACE:
3099         case SQL:
3100         case SQLCODE:
3101         case SQLERRM:
3102         case START:
3103         case STATIC:
3104         case STDDEV:
3105         case SUBTYPE:
3106         case SUBSTITUTABLE:
3107         case SUCCESSFUL:
3108         case SUM:
3109         case SYNONYM:
3110         case SYSDATE:
3111         case SYS_REFCURSOR:
3112         case TABLE:
3113         case TEMPORARY:
3114         case THEN:
3115         case TIME:
3116         case TIMESTAMP:
3117         case TIMEZONE_REGION:
3118         case TIMEZONE_ABBR:
3119         case TIMEZONE_MINUTE:
3120         case TIMEZONE_HOUR:
3121         case TO:
3122         case TRANSACTION:
3123         case TRIGGER:
3124         case TRUE:
3125         case TYPE:
3126         case UI:
3127         case UNDER:
3128         case USING:
3129         case WHILE:
3130         case YES:
3131         case SHOW:
3132         case A:
3133         case UPDATE:
3134         case VARCHAR:
3135         case VARCHAR2:
3136         case DOUBLE:
3137         case DEC:
3138         case PRECISION:
3139         case INT:
3140         case NUMERIC:
3141         case SIGNTYPE:
3142         case NCHAR:
3143         case NVARCHAR2:
3144         case STRING:
3145         case UROWID:
3146         case VARRAY:
3147         case VARYING:
3148         case BFILE:
3149         case BLOB:
3150         case CLOB:
3151         case NCLOB:
3152         case YEAR:
3153         case LOCAL:
3154         case WITH:
3155         case ZONE:
3156         case CHARACTER:
3157         case AFTER:
3158         case BEFORE:
3159         case OLD:
3160         case PARENT:
3161         case CC_IF:
3162         case ANALYZE:
3163         case ASSOCIATE:
3164         case AUDIT:
3165         case COMPOUND:
3166         case DATABASE:
3167         case CALL:
3168         case DDL:
3169         case DISASSOCIATE:
3170         case EACH:
3171         case FOLLOWS:
3172         case LOGOFF:
3173         case LOGON:
3174         case NESTED:
3175         case NOAUDIT:
3176         case SCHEMA:
3177         case SERVERERROR:
3178         case SHUTDOWN:
3179         case STARTUP:
3180         case STATEMENT:
3181         case STATISTICS:
3182         case SUSPEND:
3183         case TRUNCATE:
3184         case WRAPPED:
3185         case LIBRARY:
3186         case NAME:
3187         case STRUCT:
3188         case CONTEXT:
3189         case PARAMETERS:
3190         case LENGTH:
3191         case TDO:
3192         case MAXLEN:
3193         case CHARSETID:
3194         case CHARSETFORM:
3195         case ACCEPT:
3196         case ACCESSIBLE:
3197         case COPY:
3198         case DEFINE:
3199         case DISCONNECT:
3200         case HOST:
3201         case PRINT:
3202         case QUIT:
3203         case REMARK:
3204         case UNDEFINE:
3205         case VARIABLE:
3206         case WHENEVER:
3207         case ATTACH:
3208         case CAST:
3209         case TREAT:
3210         case TRIM:
3211         case LEFT:
3212         case RIGHT:
3213         case BOTH:
3214         case EMPTY:
3215         case MULTISET:
3216         case SUBMULTISET:
3217         case LEADING:
3218         case TRAILING:
3219         case CHAR_CS:
3220         case NCHAR_CS:
3221         case DBTIMEZONE:
3222         case SESSIONTIMEZONE:
3223         case AUTHENTICATED:
3224         case LINK:
3225         case SHARED:
3226         case DIRECTORY:
3227         case USER:
3228         case IDENTIFIER:
3229         case QUOTED_LITERAL:
3230         case SQLDATA_CLASS:
3231         case CUSTOMDATUM_CLASS:
3232         case ORADATA_CLASS:
3233         case JAVA_INTERFACE_CLASS:
3234           DeclarativeUnit();
3235           break;
3236         case CC_ERROR:
3237           jj_consume_token(CC_ERROR);
3238           Expression();
3239           jj_consume_token(CC_END);
3240           break;
3241         default:
3242           jj_la1[35] = jj_gen;
3243           jj_consume_token(-1);
3244           throw new ParseException();
3245         }
3246       }
3247       label_9:
3248       while (true) {
3249         switch (jj_nt.kind) {
3250         case CC_ELSIF:
3251           ;
3252           break;
3253         default:
3254           jj_la1[36] = jj_gen;
3255           break label_9;
3256         }
3257         jj_consume_token(CC_ELSIF);
3258         ConditionalOrExpression();
3259         jj_consume_token(CC_THEN);
3260         label_10:
3261         while (true) {
3262           switch (jj_nt.kind) {
3263           case REPLACE:
3264           case DEFINER:
3265           case CURRENT_USER:
3266           case SERIALLY_REUSABLE:
3267           case RESTRICT_REFERENCES:
3268           case EXCEPTION_INIT:
3269           case AUTONOMOUS_TRANSACTION:
3270           case LANGUAGE:
3271           case INLINE:
3272           case ADD:
3273           case AGGREGATE:
3274           case ALL:
3275           case ALTER:
3276           case AND:
3277           case ANY:
3278           case ARRAY:
3279           case AS:
3280           case ASC:
3281           case AT:
3282           case ATTRIBUTE:
3283           case AUTHID:
3284           case AVG:
3285           case BETWEEN:
3286           case BINARY_INTEGER:
3287           case BODY:
3288           case BOOLEAN:
3289           case BULK:
3290           case BY:
3291           case BYTE:
3292           case CASCADE:
3293           case CASE:
3294           case CHAR:
3295           case CHAR_BASE:
3296           case CHECK:
3297           case CLOSE:
3298           case CLUSTER:
3299           case COALESCE:
3300           case COLLECT:
3301           case COLUMN:
3302           case COMMENT:
3303           case COMMIT:
3304           case COMPRESS:
3305           case CONNECT:
3306           case CONSTANT:
3307           case CONSTRUCTOR:
3308           case CONTINUE:
3309           case CONVERT:
3310           case CREATE:
3311           case CURRENT:
3312           case CURRVAL:
3313           case CURSOR:
3314           case DATA:
3315           case DATE:
3316           case DAY:
3317           case DECLARE:
3318           case DECIMAL:
3319           case _DEFAULT:
3320           case DELETE:
3321           case DESC:
3322           case DISABLE:
3323           case DISTINCT:
3324           case DO:
3325           case DROP:
3326           case EDITIONABLE:
3327           case ELEMENT:
3328           case ELSE:
3329           case ELSIF:
3330           case ENABLE:
3331           case ESCAPE:
3332           case EXCEPT:
3333           case EXCEPTION:
3334           case EXCEPTIONS:
3335           case EXCLUSIVE:
3336           case EXECUTE:
3337           case EXISTS:
3338           case EXIT:
3339           case EXTERNAL:
3340           case EXTENDS:
3341           case EXTRACT:
3342           case FALSE:
3343           case FETCH:
3344           case FINAL:
3345           case FLOAT:
3346           case FOR:
3347           case FORALL:
3348           case FORCE:
3349           case FROM:
3350           case FUNCTION:
3351           case GLOBAL:
3352           case GOTO:
3353           case GROUP:
3354           case HASH:
3355           case HAVING:
3356           case HEAP:
3357           case HOUR:
3358           case IF:
3359           case IMMEDIATE:
3360           case IN:
3361           case INDEX:
3362           case INDICES:
3363           case INDEXTYPE:
3364           case INDICATOR:
3365           case INSERT:
3366           case INSTANTIABLE:
3367           case INTEGER:
3368           case INTERFACE:
3369           case INTERSECT:
3370           case INTERVAL:
3371           case INTO:
3372           case INVALIDATE:
3373           case IS:
3374           case ISOLATION:
3375           case JAVA:
3376           case LEVEL:
3377           case LIKE:
3378           case LIMIT:
3379           case LIMITED:
3380           case LOCK:
3381           case LONG:
3382           case LOOP:
3383           case MAP:
3384           case MAX:
3385           case MEMBER:
3386           case MERGE:
3387           case MIN:
3388           case MINUS:
3389           case MINUTE:
3390           case MLSLABEL:
3391           case MODIFY:
3392           case MOD:
3393           case MODE:
3394           case MONTH:
3395           case NATURAL:
3396           case NATURALN:
3397           case NEW:
3398           case NEXTVAL:
3399           case NO:
3400           case NOCOPY:
3401           case NONEDITIONABLE:
3402           case NOT:
3403           case NOWAIT:
3404           case NULL:
3405           case NULLIF:
3406           case NUMBER:
3407           case BFILE_BASE:
3408           case BLOB_BASE:
3409           case CLOB_BASE:
3410           case DATE_BASE:
3411           case NUMBER_BASE:
3412           case OBJECT:
3413           case OCIROWID:
3414           case OF:
3415           case OID:
3416           case ON:
3417           case OPAQUE:
3418           case OPEN:
3419           case OPERATOR:
3420           case OPTION:
3421           case OR:
3422           case ORDER:
3423           case ORGANIZATION:
3424           case OTHERS:
3425           case OUT:
3426           case OVERRIDING:
3427           case PACKAGE:
3428           case PARTITION:
3429           case PCTFREE:
3430           case PLS_INTEGER:
3431           case POSITIVE:
3432           case POSITIVEN:
3433           case PRAGMA:
3434           case PRESERVE:
3435           case PRIOR:
3436           case PROMPT:
3437           case PRIVATE:
3438           case PROCEDURE:
3439           case PUBLIC:
3440           case RAISE:
3441           case RANGE:
3442           case RAW:
3443           case REAL:
3444           case RECORD:
3445           case REF:
3446           case RELEASE:
3447           case RELIES_ON:
3448           case RENAME:
3449           case RESULT:
3450           case RETURN:
3451           case RETURNING:
3452           case REVERSE:
3453           case ROLLBACK:
3454           case ROW:
3455           case ROWS:
3456           case ROWID:
3457           case ROWNUM:
3458           case ROWTYPE:
3459           case SAVE:
3460           case SAVEPOINT:
3461           case SECOND:
3462           case SELECT:
3463           case SELF:
3464           case SEPARATE:
3465           case SET:
3466           case SHARE:
3467           case SMALLINT:
3468           case SPACE:
3469           case SQL:
3470           case SQLCODE:
3471           case SQLERRM:
3472           case START:
3473           case STATIC:
3474           case STDDEV:
3475           case SUBTYPE:
3476           case SUBSTITUTABLE:
3477           case SUCCESSFUL:
3478           case SUM:
3479           case SYNONYM:
3480           case SYSDATE:
3481           case SYS_REFCURSOR:
3482           case TABLE:
3483           case TEMPORARY:
3484           case THEN:
3485           case TIME:
3486           case TIMESTAMP:
3487           case TIMEZONE_REGION:
3488           case TIMEZONE_ABBR:
3489           case TIMEZONE_MINUTE:
3490           case TIMEZONE_HOUR:
3491           case TO:
3492           case TRANSACTION:
3493           case TRIGGER:
3494           case TRUE:
3495           case TYPE:
3496           case UI:
3497           case UNDER:
3498           case USING:
3499           case WHILE:
3500           case YES:
3501           case SHOW:
3502           case A:
3503           case UPDATE:
3504           case VARCHAR:
3505           case VARCHAR2:
3506           case DOUBLE:
3507           case DEC:
3508           case PRECISION:
3509           case INT:
3510           case NUMERIC:
3511           case SIGNTYPE:
3512           case NCHAR:
3513           case NVARCHAR2:
3514           case STRING:
3515           case UROWID:
3516           case VARRAY:
3517           case VARYING:
3518           case BFILE:
3519           case BLOB:
3520           case CLOB:
3521           case NCLOB:
3522           case YEAR:
3523           case LOCAL:
3524           case WITH:
3525           case ZONE:
3526           case CHARACTER:
3527           case AFTER:
3528           case BEFORE:
3529           case OLD:
3530           case PARENT:
3531           case CC_IF:
3532           case CC_ERROR:
3533           case ANALYZE:
3534           case ASSOCIATE:
3535           case AUDIT:
3536           case COMPOUND:
3537           case DATABASE:
3538           case CALL:
3539           case DDL:
3540           case DISASSOCIATE:
3541           case EACH:
3542           case FOLLOWS:
3543           case LOGOFF:
3544           case LOGON:
3545           case NESTED:
3546           case NOAUDIT:
3547           case SCHEMA:
3548           case SERVERERROR:
3549           case SHUTDOWN:
3550           case STARTUP:
3551           case STATEMENT:
3552           case STATISTICS:
3553           case SUSPEND:
3554           case TRUNCATE:
3555           case WRAPPED:
3556           case LIBRARY:
3557           case NAME:
3558           case STRUCT:
3559           case CONTEXT:
3560           case PARAMETERS:
3561           case LENGTH:
3562           case TDO:
3563           case MAXLEN:
3564           case CHARSETID:
3565           case CHARSETFORM:
3566           case ACCEPT:
3567           case ACCESSIBLE:
3568           case COPY:
3569           case DEFINE:
3570           case DISCONNECT:
3571           case HOST:
3572           case PRINT:
3573           case QUIT:
3574           case REMARK:
3575           case UNDEFINE:
3576           case VARIABLE:
3577           case WHENEVER:
3578           case ATTACH:
3579           case CAST:
3580           case TREAT:
3581           case TRIM:
3582           case LEFT:
3583           case RIGHT:
3584           case BOTH:
3585           case EMPTY:
3586           case MULTISET:
3587           case SUBMULTISET:
3588           case LEADING:
3589           case TRAILING:
3590           case CHAR_CS:
3591           case NCHAR_CS:
3592           case DBTIMEZONE:
3593           case SESSIONTIMEZONE:
3594           case AUTHENTICATED:
3595           case LINK:
3596           case SHARED:
3597           case DIRECTORY:
3598           case USER:
3599           case IDENTIFIER:
3600           case QUOTED_LITERAL:
3601           case SQLDATA_CLASS:
3602           case CUSTOMDATUM_CLASS:
3603           case ORADATA_CLASS:
3604           case JAVA_INTERFACE_CLASS:
3605             ;
3606             break;
3607           default:
3608             jj_la1[37] = jj_gen;
3609             break label_10;
3610           }
3611           switch (jj_nt.kind) {
3612           case REPLACE:
3613           case DEFINER:
3614           case CURRENT_USER:
3615           case SERIALLY_REUSABLE:
3616           case RESTRICT_REFERENCES:
3617           case EXCEPTION_INIT:
3618           case AUTONOMOUS_TRANSACTION:
3619           case LANGUAGE:
3620           case INLINE:
3621           case ADD:
3622           case AGGREGATE:
3623           case ALL:
3624           case ALTER:
3625           case AND:
3626           case ANY:
3627           case ARRAY:
3628           case AS:
3629           case ASC:
3630           case AT:
3631           case ATTRIBUTE:
3632           case AUTHID:
3633           case AVG:
3634           case BETWEEN:
3635           case BINARY_INTEGER:
3636           case BODY:
3637           case BOOLEAN:
3638           case BULK:
3639           case BY:
3640           case BYTE:
3641           case CASCADE:
3642           case CASE:
3643           case CHAR:
3644           case CHAR_BASE:
3645           case CHECK:
3646           case CLOSE:
3647           case CLUSTER:
3648           case COALESCE:
3649           case COLLECT:
3650           case COLUMN:
3651           case COMMENT:
3652           case COMMIT:
3653           case COMPRESS:
3654           case CONNECT:
3655           case CONSTANT:
3656           case CONSTRUCTOR:
3657           case CONTINUE:
3658           case CONVERT:
3659           case CREATE:
3660           case CURRENT:
3661           case CURRVAL:
3662           case CURSOR:
3663           case DATA:
3664           case DATE:
3665           case DAY:
3666           case DECLARE:
3667           case DECIMAL:
3668           case _DEFAULT:
3669           case DELETE:
3670           case DESC:
3671           case DISABLE:
3672           case DISTINCT:
3673           case DO:
3674           case DROP:
3675           case EDITIONABLE:
3676           case ELEMENT:
3677           case ELSE:
3678           case ELSIF:
3679           case ENABLE:
3680           case ESCAPE:
3681           case EXCEPT:
3682           case EXCEPTION:
3683           case EXCEPTIONS:
3684           case EXCLUSIVE:
3685           case EXECUTE:
3686           case EXISTS:
3687           case EXIT:
3688           case EXTERNAL:
3689           case EXTENDS:
3690           case EXTRACT:
3691           case FALSE:
3692           case FETCH:
3693           case FINAL:
3694           case FLOAT:
3695           case FOR:
3696           case FORALL:
3697           case FORCE:
3698           case FROM:
3699           case FUNCTION:
3700           case GLOBAL:
3701           case GOTO:
3702           case GROUP:
3703           case HASH:
3704           case HAVING:
3705           case HEAP:
3706           case HOUR:
3707           case IF:
3708           case IMMEDIATE:
3709           case IN:
3710           case INDEX:
3711           case INDICES:
3712           case INDEXTYPE:
3713           case INDICATOR:
3714           case INSERT:
3715           case INSTANTIABLE:
3716           case INTEGER:
3717           case INTERFACE:
3718           case INTERSECT:
3719           case INTERVAL:
3720           case INTO:
3721           case INVALIDATE:
3722           case IS:
3723           case ISOLATION:
3724           case JAVA:
3725           case LEVEL:
3726           case LIKE:
3727           case LIMIT:
3728           case LIMITED:
3729           case LOCK:
3730           case LONG:
3731           case LOOP:
3732           case MAP:
3733           case MAX:
3734           case MEMBER:
3735           case MERGE:
3736           case MIN:
3737           case MINUS:
3738           case MINUTE:
3739           case MLSLABEL:
3740           case MODIFY:
3741           case MOD:
3742           case MODE:
3743           case MONTH:
3744           case NATURAL:
3745           case NATURALN:
3746           case NEW:
3747           case NEXTVAL:
3748           case NO:
3749           case NOCOPY:
3750           case NONEDITIONABLE:
3751           case NOT:
3752           case NOWAIT:
3753           case NULL:
3754           case NULLIF:
3755           case NUMBER:
3756           case BFILE_BASE:
3757           case BLOB_BASE:
3758           case CLOB_BASE:
3759           case DATE_BASE:
3760           case NUMBER_BASE:
3761           case OBJECT:
3762           case OCIROWID:
3763           case OF:
3764           case OID:
3765           case ON:
3766           case OPAQUE:
3767           case OPEN:
3768           case OPERATOR:
3769           case OPTION:
3770           case OR:
3771           case ORDER:
3772           case ORGANIZATION:
3773           case OTHERS:
3774           case OUT:
3775           case OVERRIDING:
3776           case PACKAGE:
3777           case PARTITION:
3778           case PCTFREE:
3779           case PLS_INTEGER:
3780           case POSITIVE:
3781           case POSITIVEN:
3782           case PRAGMA:
3783           case PRESERVE:
3784           case PRIOR:
3785           case PROMPT:
3786           case PRIVATE:
3787           case PROCEDURE:
3788           case PUBLIC:
3789           case RAISE:
3790           case RANGE:
3791           case RAW:
3792           case REAL:
3793           case RECORD:
3794           case REF:
3795           case RELEASE:
3796           case RELIES_ON:
3797           case RENAME:
3798           case RESULT:
3799           case RETURN:
3800           case RETURNING:
3801           case REVERSE:
3802           case ROLLBACK:
3803           case ROW:
3804           case ROWS:
3805           case ROWID:
3806           case ROWNUM:
3807           case ROWTYPE:
3808           case SAVE:
3809           case SAVEPOINT:
3810           case SECOND:
3811           case SELECT:
3812           case SELF:
3813           case SEPARATE:
3814           case SET:
3815           case SHARE:
3816           case SMALLINT:
3817           case SPACE:
3818           case SQL:
3819           case SQLCODE:
3820           case SQLERRM:
3821           case START:
3822           case STATIC:
3823           case STDDEV:
3824           case SUBTYPE:
3825           case SUBSTITUTABLE:
3826           case SUCCESSFUL:
3827           case SUM:
3828           case SYNONYM:
3829           case SYSDATE:
3830           case SYS_REFCURSOR:
3831           case TABLE:
3832           case TEMPORARY:
3833           case THEN:
3834           case TIME:
3835           case TIMESTAMP:
3836           case TIMEZONE_REGION:
3837           case TIMEZONE_ABBR:
3838           case TIMEZONE_MINUTE:
3839           case TIMEZONE_HOUR:
3840           case TO:
3841           case TRANSACTION:
3842           case TRIGGER:
3843           case TRUE:
3844           case TYPE:
3845           case UI:
3846           case UNDER:
3847           case USING:
3848           case WHILE:
3849           case YES:
3850           case SHOW:
3851           case A:
3852           case UPDATE:
3853           case VARCHAR:
3854           case VARCHAR2:
3855           case DOUBLE:
3856           case DEC:
3857           case PRECISION:
3858           case INT:
3859           case NUMERIC:
3860           case SIGNTYPE:
3861           case NCHAR:
3862           case NVARCHAR2:
3863           case STRING:
3864           case UROWID:
3865           case VARRAY:
3866           case VARYING:
3867           case BFILE:
3868           case BLOB:
3869           case CLOB:
3870           case NCLOB:
3871           case YEAR:
3872           case LOCAL:
3873           case WITH:
3874           case ZONE:
3875           case CHARACTER:
3876           case AFTER:
3877           case BEFORE:
3878           case OLD:
3879           case PARENT:
3880           case CC_IF:
3881           case ANALYZE:
3882           case ASSOCIATE:
3883           case AUDIT:
3884           case COMPOUND:
3885           case DATABASE:
3886           case CALL:
3887           case DDL:
3888           case DISASSOCIATE:
3889           case EACH:
3890           case FOLLOWS:
3891           case LOGOFF:
3892           case LOGON:
3893           case NESTED:
3894           case NOAUDIT:
3895           case SCHEMA:
3896           case SERVERERROR:
3897           case SHUTDOWN:
3898           case STARTUP:
3899           case STATEMENT:
3900           case STATISTICS:
3901           case SUSPEND:
3902           case TRUNCATE:
3903           case WRAPPED:
3904           case LIBRARY:
3905           case NAME:
3906           case STRUCT:
3907           case CONTEXT:
3908           case PARAMETERS:
3909           case LENGTH:
3910           case TDO:
3911           case MAXLEN:
3912           case CHARSETID:
3913           case CHARSETFORM:
3914           case ACCEPT:
3915           case ACCESSIBLE:
3916           case COPY:
3917           case DEFINE:
3918           case DISCONNECT:
3919           case HOST:
3920           case PRINT:
3921           case QUIT:
3922           case REMARK:
3923           case UNDEFINE:
3924           case VARIABLE:
3925           case WHENEVER:
3926           case ATTACH:
3927           case CAST:
3928           case TREAT:
3929           case TRIM:
3930           case LEFT:
3931           case RIGHT:
3932           case BOTH:
3933           case EMPTY:
3934           case MULTISET:
3935           case SUBMULTISET:
3936           case LEADING:
3937           case TRAILING:
3938           case CHAR_CS:
3939           case NCHAR_CS:
3940           case DBTIMEZONE:
3941           case SESSIONTIMEZONE:
3942           case AUTHENTICATED:
3943           case LINK:
3944           case SHARED:
3945           case DIRECTORY:
3946           case USER:
3947           case IDENTIFIER:
3948           case QUOTED_LITERAL:
3949           case SQLDATA_CLASS:
3950           case CUSTOMDATUM_CLASS:
3951           case ORADATA_CLASS:
3952           case JAVA_INTERFACE_CLASS:
3953             DeclarativeUnit();
3954             break;
3955           case CC_ERROR:
3956             jj_consume_token(CC_ERROR);
3957             Expression();
3958             jj_consume_token(CC_END);
3959             break;
3960           default:
3961             jj_la1[38] = jj_gen;
3962             jj_consume_token(-1);
3963             throw new ParseException();
3964           }
3965         }
3966       }
3967       label_11:
3968       while (true) {
3969         switch (jj_nt.kind) {
3970         case CC_ELSE:
3971           ;
3972           break;
3973         default:
3974           jj_la1[39] = jj_gen;
3975           break label_11;
3976         }
3977         jj_consume_token(CC_ELSE);
3978         label_12:
3979         while (true) {
3980           switch (jj_nt.kind) {
3981           case REPLACE:
3982           case DEFINER:
3983           case CURRENT_USER:
3984           case SERIALLY_REUSABLE:
3985           case RESTRICT_REFERENCES:
3986           case EXCEPTION_INIT:
3987           case AUTONOMOUS_TRANSACTION:
3988           case LANGUAGE:
3989           case INLINE:
3990           case ADD:
3991           case AGGREGATE:
3992           case ALL:
3993           case ALTER:
3994           case AND:
3995           case ANY:
3996           case ARRAY:
3997           case AS:
3998           case ASC:
3999           case AT:
4000           case ATTRIBUTE:
4001           case AUTHID:
4002           case AVG:
4003           case BETWEEN:
4004           case BINARY_INTEGER:
4005           case BODY:
4006           case BOOLEAN:
4007           case BULK:
4008           case BY:
4009           case BYTE:
4010           case CASCADE:
4011           case CASE:
4012           case CHAR:
4013           case CHAR_BASE:
4014           case CHECK:
4015           case CLOSE:
4016           case CLUSTER:
4017           case COALESCE:
4018           case COLLECT:
4019           case COLUMN:
4020           case COMMENT:
4021           case COMMIT:
4022           case COMPRESS:
4023           case CONNECT:
4024           case CONSTANT:
4025           case CONSTRUCTOR:
4026           case CONTINUE:
4027           case CONVERT:
4028           case CREATE:
4029           case CURRENT:
4030           case CURRVAL:
4031           case CURSOR:
4032           case DATA:
4033           case DATE:
4034           case DAY:
4035           case DECLARE:
4036           case DECIMAL:
4037           case _DEFAULT:
4038           case DELETE:
4039           case DESC:
4040           case DISABLE:
4041           case DISTINCT:
4042           case DO:
4043           case DROP:
4044           case EDITIONABLE:
4045           case ELEMENT:
4046           case ELSE:
4047           case ELSIF:
4048           case ENABLE:
4049           case ESCAPE:
4050           case EXCEPT:
4051           case EXCEPTION:
4052           case EXCEPTIONS:
4053           case EXCLUSIVE:
4054           case EXECUTE:
4055           case EXISTS:
4056           case EXIT:
4057           case EXTERNAL:
4058           case EXTENDS:
4059           case EXTRACT:
4060           case FALSE:
4061           case FETCH:
4062           case FINAL:
4063           case FLOAT:
4064           case FOR:
4065           case FORALL:
4066           case FORCE:
4067           case FROM:
4068           case FUNCTION:
4069           case GLOBAL:
4070           case GOTO:
4071           case GROUP:
4072           case HASH:
4073           case HAVING:
4074           case HEAP:
4075           case HOUR:
4076           case IF:
4077           case IMMEDIATE:
4078           case IN:
4079           case INDEX:
4080           case INDICES:
4081           case INDEXTYPE:
4082           case INDICATOR:
4083           case INSERT:
4084           case INSTANTIABLE:
4085           case INTEGER:
4086           case INTERFACE:
4087           case INTERSECT:
4088           case INTERVAL:
4089           case INTO:
4090           case INVALIDATE:
4091           case IS:
4092           case ISOLATION:
4093           case JAVA:
4094           case LEVEL:
4095           case LIKE:
4096           case LIMIT:
4097           case LIMITED:
4098           case LOCK:
4099           case LONG:
4100           case LOOP:
4101           case MAP:
4102           case MAX:
4103           case MEMBER:
4104           case MERGE:
4105           case MIN:
4106           case MINUS:
4107           case MINUTE:
4108           case MLSLABEL:
4109           case MODIFY:
4110           case MOD:
4111           case MODE:
4112           case MONTH:
4113           case NATURAL:
4114           case NATURALN:
4115           case NEW:
4116           case NEXTVAL:
4117           case NO:
4118           case NOCOPY:
4119           case NONEDITIONABLE:
4120           case NOT:
4121           case NOWAIT:
4122           case NULL:
4123           case NULLIF:
4124           case NUMBER:
4125           case BFILE_BASE:
4126           case BLOB_BASE:
4127           case CLOB_BASE:
4128           case DATE_BASE:
4129           case NUMBER_BASE:
4130           case OBJECT:
4131           case OCIROWID:
4132           case OF:
4133           case OID:
4134           case ON:
4135           case OPAQUE:
4136           case OPEN:
4137           case OPERATOR:
4138           case OPTION:
4139           case OR:
4140           case ORDER:
4141           case ORGANIZATION:
4142           case OTHERS:
4143           case OUT:
4144           case OVERRIDING:
4145           case PACKAGE:
4146           case PARTITION:
4147           case PCTFREE:
4148           case PLS_INTEGER:
4149           case POSITIVE:
4150           case POSITIVEN:
4151           case PRAGMA:
4152           case PRESERVE:
4153           case PRIOR:
4154           case PROMPT:
4155           case PRIVATE:
4156           case PROCEDURE:
4157           case PUBLIC:
4158           case RAISE:
4159           case RANGE:
4160           case RAW:
4161           case REAL:
4162           case RECORD:
4163           case REF:
4164           case RELEASE:
4165           case RELIES_ON:
4166           case RENAME:
4167           case RESULT:
4168           case RETURN:
4169           case RETURNING:
4170           case REVERSE:
4171           case ROLLBACK:
4172           case ROW:
4173           case ROWS:
4174           case ROWID:
4175           case ROWNUM:
4176           case ROWTYPE:
4177           case SAVE:
4178           case SAVEPOINT:
4179           case SECOND:
4180           case SELECT:
4181           case SELF:
4182           case SEPARATE:
4183           case SET:
4184           case SHARE:
4185           case SMALLINT:
4186           case SPACE:
4187           case SQL:
4188           case SQLCODE:
4189           case SQLERRM:
4190           case START:
4191           case STATIC:
4192           case STDDEV:
4193           case SUBTYPE:
4194           case SUBSTITUTABLE:
4195           case SUCCESSFUL:
4196           case SUM:
4197           case SYNONYM:
4198           case SYSDATE:
4199           case SYS_REFCURSOR:
4200           case TABLE:
4201           case TEMPORARY:
4202           case THEN:
4203           case TIME:
4204           case TIMESTAMP:
4205           case TIMEZONE_REGION:
4206           case TIMEZONE_ABBR:
4207           case TIMEZONE_MINUTE:
4208           case TIMEZONE_HOUR:
4209           case TO:
4210           case TRANSACTION:
4211           case TRIGGER:
4212           case TRUE:
4213           case TYPE:
4214           case UI:
4215           case UNDER:
4216           case USING:
4217           case WHILE:
4218           case YES:
4219           case SHOW:
4220           case A:
4221           case UPDATE:
4222           case VARCHAR:
4223           case VARCHAR2:
4224           case DOUBLE:
4225           case DEC:
4226           case PRECISION:
4227           case INT:
4228           case NUMERIC:
4229           case SIGNTYPE:
4230           case NCHAR:
4231           case NVARCHAR2:
4232           case STRING:
4233           case UROWID:
4234           case VARRAY:
4235           case VARYING:
4236           case BFILE:
4237           case BLOB:
4238           case CLOB:
4239           case NCLOB:
4240           case YEAR:
4241           case LOCAL:
4242           case WITH:
4243           case ZONE:
4244           case CHARACTER:
4245           case AFTER:
4246           case BEFORE:
4247           case OLD:
4248           case PARENT:
4249           case CC_IF:
4250           case CC_ERROR:
4251           case ANALYZE:
4252           case ASSOCIATE:
4253           case AUDIT:
4254           case COMPOUND:
4255           case DATABASE:
4256           case CALL:
4257           case DDL:
4258           case DISASSOCIATE:
4259           case EACH:
4260           case FOLLOWS:
4261           case LOGOFF:
4262           case LOGON:
4263           case NESTED:
4264           case NOAUDIT:
4265           case SCHEMA:
4266           case SERVERERROR:
4267           case SHUTDOWN:
4268           case STARTUP:
4269           case STATEMENT:
4270           case STATISTICS:
4271           case SUSPEND:
4272           case TRUNCATE:
4273           case WRAPPED:
4274           case LIBRARY:
4275           case NAME:
4276           case STRUCT:
4277           case CONTEXT:
4278           case PARAMETERS:
4279           case LENGTH:
4280           case TDO:
4281           case MAXLEN:
4282           case CHARSETID:
4283           case CHARSETFORM:
4284           case ACCEPT:
4285           case ACCESSIBLE:
4286           case COPY:
4287           case DEFINE:
4288           case DISCONNECT:
4289           case HOST:
4290           case PRINT:
4291           case QUIT:
4292           case REMARK:
4293           case UNDEFINE:
4294           case VARIABLE:
4295           case WHENEVER:
4296           case ATTACH:
4297           case CAST:
4298           case TREAT:
4299           case TRIM:
4300           case LEFT:
4301           case RIGHT:
4302           case BOTH:
4303           case EMPTY:
4304           case MULTISET:
4305           case SUBMULTISET:
4306           case LEADING:
4307           case TRAILING:
4308           case CHAR_CS:
4309           case NCHAR_CS:
4310           case DBTIMEZONE:
4311           case SESSIONTIMEZONE:
4312           case AUTHENTICATED:
4313           case LINK:
4314           case SHARED:
4315           case DIRECTORY:
4316           case USER:
4317           case IDENTIFIER:
4318           case QUOTED_LITERAL:
4319           case SQLDATA_CLASS:
4320           case CUSTOMDATUM_CLASS:
4321           case ORADATA_CLASS:
4322           case JAVA_INTERFACE_CLASS:
4323             ;
4324             break;
4325           default:
4326             jj_la1[40] = jj_gen;
4327             break label_12;
4328           }
4329           switch (jj_nt.kind) {
4330           case REPLACE:
4331           case DEFINER:
4332           case CURRENT_USER:
4333           case SERIALLY_REUSABLE:
4334           case RESTRICT_REFERENCES:
4335           case EXCEPTION_INIT:
4336           case AUTONOMOUS_TRANSACTION:
4337           case LANGUAGE:
4338           case INLINE:
4339           case ADD:
4340           case AGGREGATE:
4341           case ALL:
4342           case ALTER:
4343           case AND:
4344           case ANY:
4345           case ARRAY:
4346           case AS:
4347           case ASC:
4348           case AT:
4349           case ATTRIBUTE:
4350           case AUTHID:
4351           case AVG:
4352           case BETWEEN:
4353           case BINARY_INTEGER:
4354           case BODY:
4355           case BOOLEAN:
4356           case BULK:
4357           case BY:
4358           case BYTE:
4359           case CASCADE:
4360           case CASE:
4361           case CHAR:
4362           case CHAR_BASE:
4363           case CHECK:
4364           case CLOSE:
4365           case CLUSTER:
4366           case COALESCE:
4367           case COLLECT:
4368           case COLUMN:
4369           case COMMENT:
4370           case COMMIT:
4371           case COMPRESS:
4372           case CONNECT:
4373           case CONSTANT:
4374           case CONSTRUCTOR:
4375           case CONTINUE:
4376           case CONVERT:
4377           case CREATE:
4378           case CURRENT:
4379           case CURRVAL:
4380           case CURSOR:
4381           case DATA:
4382           case DATE:
4383           case DAY:
4384           case DECLARE:
4385           case DECIMAL:
4386           case _DEFAULT:
4387           case DELETE:
4388           case DESC:
4389           case DISABLE:
4390           case DISTINCT:
4391           case DO:
4392           case DROP:
4393           case EDITIONABLE:
4394           case ELEMENT:
4395           case ELSE:
4396           case ELSIF:
4397           case ENABLE:
4398           case ESCAPE:
4399           case EXCEPT:
4400           case EXCEPTION:
4401           case EXCEPTIONS:
4402           case EXCLUSIVE:
4403           case EXECUTE:
4404           case EXISTS:
4405           case EXIT:
4406           case EXTERNAL:
4407           case EXTENDS:
4408           case EXTRACT:
4409           case FALSE:
4410           case FETCH:
4411           case FINAL:
4412           case FLOAT:
4413           case FOR:
4414           case FORALL:
4415           case FORCE:
4416           case FROM:
4417           case FUNCTION:
4418           case GLOBAL:
4419           case GOTO:
4420           case GROUP:
4421           case HASH:
4422           case HAVING:
4423           case HEAP:
4424           case HOUR:
4425           case IF:
4426           case IMMEDIATE:
4427           case IN:
4428           case INDEX:
4429           case INDICES:
4430           case INDEXTYPE:
4431           case INDICATOR:
4432           case INSERT:
4433           case INSTANTIABLE:
4434           case INTEGER:
4435           case INTERFACE:
4436           case INTERSECT:
4437           case INTERVAL:
4438           case INTO:
4439           case INVALIDATE:
4440           case IS:
4441           case ISOLATION:
4442           case JAVA:
4443           case LEVEL:
4444           case LIKE:
4445           case LIMIT:
4446           case LIMITED:
4447           case LOCK:
4448           case LONG:
4449           case LOOP:
4450           case MAP:
4451           case MAX:
4452           case MEMBER:
4453           case MERGE:
4454           case MIN:
4455           case MINUS:
4456           case MINUTE:
4457           case MLSLABEL:
4458           case MODIFY:
4459           case MOD:
4460           case MODE:
4461           case MONTH:
4462           case NATURAL:
4463           case NATURALN:
4464           case NEW:
4465           case NEXTVAL:
4466           case NO:
4467           case NOCOPY:
4468           case NONEDITIONABLE:
4469           case NOT:
4470           case NOWAIT:
4471           case NULL:
4472           case NULLIF:
4473           case NUMBER:
4474           case BFILE_BASE:
4475           case BLOB_BASE:
4476           case CLOB_BASE:
4477           case DATE_BASE:
4478           case NUMBER_BASE:
4479           case OBJECT:
4480           case OCIROWID:
4481           case OF:
4482           case OID:
4483           case ON:
4484           case OPAQUE:
4485           case OPEN:
4486           case OPERATOR:
4487           case OPTION:
4488           case OR:
4489           case ORDER:
4490           case ORGANIZATION:
4491           case OTHERS:
4492           case OUT:
4493           case OVERRIDING:
4494           case PACKAGE:
4495           case PARTITION:
4496           case PCTFREE:
4497           case PLS_INTEGER:
4498           case POSITIVE:
4499           case POSITIVEN:
4500           case PRAGMA:
4501           case PRESERVE:
4502           case PRIOR:
4503           case PROMPT:
4504           case PRIVATE:
4505           case PROCEDURE:
4506           case PUBLIC:
4507           case RAISE:
4508           case RANGE:
4509           case RAW:
4510           case REAL:
4511           case RECORD:
4512           case REF:
4513           case RELEASE:
4514           case RELIES_ON:
4515           case RENAME:
4516           case RESULT:
4517           case RETURN:
4518           case RETURNING:
4519           case REVERSE:
4520           case ROLLBACK:
4521           case ROW:
4522           case ROWS:
4523           case ROWID:
4524           case ROWNUM:
4525           case ROWTYPE:
4526           case SAVE:
4527           case SAVEPOINT:
4528           case SECOND:
4529           case SELECT:
4530           case SELF:
4531           case SEPARATE:
4532           case SET:
4533           case SHARE:
4534           case SMALLINT:
4535           case SPACE:
4536           case SQL:
4537           case SQLCODE:
4538           case SQLERRM:
4539           case START:
4540           case STATIC:
4541           case STDDEV:
4542           case SUBTYPE:
4543           case SUBSTITUTABLE:
4544           case SUCCESSFUL:
4545           case SUM:
4546           case SYNONYM:
4547           case SYSDATE:
4548           case SYS_REFCURSOR:
4549           case TABLE:
4550           case TEMPORARY:
4551           case THEN:
4552           case TIME:
4553           case TIMESTAMP:
4554           case TIMEZONE_REGION:
4555           case TIMEZONE_ABBR:
4556           case TIMEZONE_MINUTE:
4557           case TIMEZONE_HOUR:
4558           case TO:
4559           case TRANSACTION:
4560           case TRIGGER:
4561           case TRUE:
4562           case TYPE:
4563           case UI:
4564           case UNDER:
4565           case USING:
4566           case WHILE:
4567           case YES:
4568           case SHOW:
4569           case A:
4570           case UPDATE:
4571           case VARCHAR:
4572           case VARCHAR2:
4573           case DOUBLE:
4574           case DEC:
4575           case PRECISION:
4576           case INT:
4577           case NUMERIC:
4578           case SIGNTYPE:
4579           case NCHAR:
4580           case NVARCHAR2:
4581           case STRING:
4582           case UROWID:
4583           case VARRAY:
4584           case VARYING:
4585           case BFILE:
4586           case BLOB:
4587           case CLOB:
4588           case NCLOB:
4589           case YEAR:
4590           case LOCAL:
4591           case WITH:
4592           case ZONE:
4593           case CHARACTER:
4594           case AFTER:
4595           case BEFORE:
4596           case OLD:
4597           case PARENT:
4598           case CC_IF:
4599           case ANALYZE:
4600           case ASSOCIATE:
4601           case AUDIT:
4602           case COMPOUND:
4603           case DATABASE:
4604           case CALL:
4605           case DDL:
4606           case DISASSOCIATE:
4607           case EACH:
4608           case FOLLOWS:
4609           case LOGOFF:
4610           case LOGON:
4611           case NESTED:
4612           case NOAUDIT:
4613           case SCHEMA:
4614           case SERVERERROR:
4615           case SHUTDOWN:
4616           case STARTUP:
4617           case STATEMENT:
4618           case STATISTICS:
4619           case SUSPEND:
4620           case TRUNCATE:
4621           case WRAPPED:
4622           case LIBRARY:
4623           case NAME:
4624           case STRUCT:
4625           case CONTEXT:
4626           case PARAMETERS:
4627           case LENGTH:
4628           case TDO:
4629           case MAXLEN:
4630           case CHARSETID:
4631           case CHARSETFORM:
4632           case ACCEPT:
4633           case ACCESSIBLE:
4634           case COPY:
4635           case DEFINE:
4636           case DISCONNECT:
4637           case HOST:
4638           case PRINT:
4639           case QUIT:
4640           case REMARK:
4641           case UNDEFINE:
4642           case VARIABLE:
4643           case WHENEVER:
4644           case ATTACH:
4645           case CAST:
4646           case TREAT:
4647           case TRIM:
4648           case LEFT:
4649           case RIGHT:
4650           case BOTH:
4651           case EMPTY:
4652           case MULTISET:
4653           case SUBMULTISET:
4654           case LEADING:
4655           case TRAILING:
4656           case CHAR_CS:
4657           case NCHAR_CS:
4658           case DBTIMEZONE:
4659           case SESSIONTIMEZONE:
4660           case AUTHENTICATED:
4661           case LINK:
4662           case SHARED:
4663           case DIRECTORY:
4664           case USER:
4665           case IDENTIFIER:
4666           case QUOTED_LITERAL:
4667           case SQLDATA_CLASS:
4668           case CUSTOMDATUM_CLASS:
4669           case ORADATA_CLASS:
4670           case JAVA_INTERFACE_CLASS:
4671             DeclarativeUnit();
4672             break;
4673           case CC_ERROR:
4674             jj_consume_token(CC_ERROR);
4675             Expression();
4676             jj_consume_token(CC_END);
4677             break;
4678           default:
4679             jj_la1[41] = jj_gen;
4680             jj_consume_token(-1);
4681             throw new ParseException();
4682           }
4683         }
4684       }
4685       jj_consume_token(CC_END);
4686         jjtree.closeNodeScope(jjtn000, true);
4687         jjtc000 = false;
4688         {if (true) return jjtn000 ;}
4689     } catch (Throwable jjte000) {
4690           if (jjtc000) {
4691             jjtree.clearNodeScope(jjtn000);
4692             jjtc000 = false;
4693           } else {
4694             jjtree.popNode();
4695           }
4696           if (jjte000 instanceof RuntimeException) {
4697             {if (true) throw (RuntimeException)jjte000;}
4698           }
4699           if (jjte000 instanceof ParseException) {
4700             {if (true) throw (ParseException)jjte000;}
4701           }
4702           {if (true) throw (Error)jjte000;}
4703     } finally {
4704           if (jjtc000) {
4705             jjtree.closeNodeScope(jjtn000, true);
4706           }
4707     }
4708     throw new Error("Missing return statement in function");
4709   }
4710 
4711 /**
4712  * 2006-05-22 - Matthias Hendler - Printing of custom tag "@deprecated" removed.
4713  *                                 Printing of any custom tag added. Now user can define his own
4714  *								   custom tags which he can evaluate in the XSLT.
4715  *                                 This methode also documents global functions/procedures.
4716  */
4717   final public ASTProgramUnit ProgramUnit() throws ParseException {
4718  /*@bgen(jjtree) ProgramUnit */
4719   ASTProgramUnit jjtn000 = new ASTProgramUnit(this, JJTPROGRAMUNIT);
4720   boolean jjtc000 = true;
4721   jjtree.openNodeScope(jjtn000);
4722     try {
4723       switch (jj_nt.kind) {
4724       case CREATE:
4725         jj_consume_token(CREATE);
4726         switch (jj_nt.kind) {
4727         case OR:
4728           jj_consume_token(OR);
4729           jj_consume_token(REPLACE);
4730           break;
4731         default:
4732           jj_la1[42] = jj_gen;
4733           ;
4734         }
4735         switch (jj_nt.kind) {
4736         case EDITIONABLE:
4737         case NONEDITIONABLE:
4738           switch (jj_nt.kind) {
4739           case EDITIONABLE:
4740             jj_consume_token(EDITIONABLE);
4741             break;
4742           case NONEDITIONABLE:
4743             jj_consume_token(NONEDITIONABLE);
4744             break;
4745           default:
4746             jj_la1[43] = jj_gen;
4747             jj_consume_token(-1);
4748             throw new ParseException();
4749           }
4750           break;
4751         default:
4752           jj_la1[44] = jj_gen;
4753           ;
4754         }
4755         break;
4756       default:
4757         jj_la1[45] = jj_gen;
4758         ;
4759       }
4760       MethodDeclarator();
4761       switch (jj_nt.kind) {
4762       case WRAPPED:
4763         WrappedObject();
4764         break;
4765       case 4:
4766       case AGGREGATE:
4767       case AS:
4768       case AUTHID:
4769       case DETERMINISTIC:
4770       case IS:
4771       case PARALLEL_ENABLE:
4772       case PIPELINED:
4773       case RESULT_CACHE:
4774       case ACCESSIBLE:
4775         label_13:
4776         while (true) {
4777           switch (jj_nt.kind) {
4778           case AUTHID:
4779           case DETERMINISTIC:
4780           case PARALLEL_ENABLE:
4781           case PIPELINED:
4782           case RESULT_CACHE:
4783           case ACCESSIBLE:
4784             ;
4785             break;
4786           default:
4787             jj_la1[46] = jj_gen;
4788             break label_13;
4789           }
4790           switch (jj_nt.kind) {
4791           case AUTHID:
4792             jj_consume_token(AUTHID);
4793             switch (jj_nt.kind) {
4794             case CURRENT_USER:
4795               jj_consume_token(CURRENT_USER);
4796               break;
4797             case DEFINER:
4798               jj_consume_token(DEFINER);
4799               break;
4800             default:
4801               jj_la1[47] = jj_gen;
4802               jj_consume_token(-1);
4803               throw new ParseException();
4804             }
4805             break;
4806           case DETERMINISTIC:
4807             jj_consume_token(DETERMINISTIC);
4808             break;
4809           case ACCESSIBLE:
4810             AccessibleByClause();
4811             break;
4812           case PARALLEL_ENABLE:
4813             jj_consume_token(PARALLEL_ENABLE);
4814             switch (jj_nt.kind) {
4815             case 5:
4816               ParallelClause();
4817               break;
4818             default:
4819               jj_la1[48] = jj_gen;
4820               ;
4821             }
4822             switch (jj_nt.kind) {
4823             case USING:
4824               jj_consume_token(USING);
4825               ID();
4826               switch (jj_nt.kind) {
4827               case 3:
4828                 jj_consume_token(3);
4829                 ID();
4830                 break;
4831               default:
4832                 jj_la1[49] = jj_gen;
4833                 ;
4834               }
4835               break;
4836             default:
4837               jj_la1[50] = jj_gen;
4838               ;
4839             }
4840             break;
4841           case PIPELINED:
4842             jj_consume_token(PIPELINED);
4843             switch (jj_nt.kind) {
4844             case CLUSTER:
4845             case ORDER:
4846             case USING:
4847               switch (jj_nt.kind) {
4848               case USING:
4849                 jj_consume_token(USING);
4850                 ID();
4851                 switch (jj_nt.kind) {
4852                 case 3:
4853                   jj_consume_token(3);
4854                   ID();
4855                   break;
4856                 default:
4857                   jj_la1[51] = jj_gen;
4858                   ;
4859                 }
4860                 break;
4861               case CLUSTER:
4862               case ORDER:
4863                 switch (jj_nt.kind) {
4864                 case ORDER:
4865                   jj_consume_token(ORDER);
4866                   break;
4867                 case CLUSTER:
4868                   jj_consume_token(CLUSTER);
4869                   break;
4870                 default:
4871                   jj_la1[52] = jj_gen;
4872                   jj_consume_token(-1);
4873                   throw new ParseException();
4874                 }
4875                 switch (jj_nt.kind) {
4876                 case REPLACE:
4877                 case DEFINER:
4878                 case CURRENT_USER:
4879                 case SERIALLY_REUSABLE:
4880                 case RESTRICT_REFERENCES:
4881                 case EXCEPTION_INIT:
4882                 case AUTONOMOUS_TRANSACTION:
4883                 case LANGUAGE:
4884                 case INLINE:
4885                 case ADD:
4886                 case AGGREGATE:
4887                 case ALL:
4888                 case ALTER:
4889                 case AND:
4890                 case ANY:
4891                 case ARRAY:
4892                 case AS:
4893                 case ASC:
4894                 case AT:
4895                 case ATTRIBUTE:
4896                 case AUTHID:
4897                 case AVG:
4898                 case BETWEEN:
4899                 case BINARY_INTEGER:
4900                 case BODY:
4901                 case BOOLEAN:
4902                 case BULK:
4903                 case BY:
4904                 case BYTE:
4905                 case CASCADE:
4906                 case CASE:
4907                 case CHAR:
4908                 case CHAR_BASE:
4909                 case CHECK:
4910                 case CLOSE:
4911                 case CLUSTER:
4912                 case COALESCE:
4913                 case COLLECT:
4914                 case COLUMN:
4915                 case COMMENT:
4916                 case COMMIT:
4917                 case COMPRESS:
4918                 case CONNECT:
4919                 case CONSTANT:
4920                 case CONSTRUCTOR:
4921                 case CONTINUE:
4922                 case CONVERT:
4923                 case CREATE:
4924                 case CURRENT:
4925                 case CURRVAL:
4926                 case CURSOR:
4927                 case DATA:
4928                 case DATE:
4929                 case DAY:
4930                 case DECLARE:
4931                 case DECIMAL:
4932                 case _DEFAULT:
4933                 case DELETE:
4934                 case DESC:
4935                 case DISABLE:
4936                 case DISTINCT:
4937                 case DO:
4938                 case DROP:
4939                 case EDITIONABLE:
4940                 case ELEMENT:
4941                 case ELSE:
4942                 case ELSIF:
4943                 case ENABLE:
4944                 case ESCAPE:
4945                 case EXCEPT:
4946                 case EXCEPTION:
4947                 case EXCEPTIONS:
4948                 case EXCLUSIVE:
4949                 case EXECUTE:
4950                 case EXISTS:
4951                 case EXIT:
4952                 case EXTERNAL:
4953                 case EXTENDS:
4954                 case EXTRACT:
4955                 case FALSE:
4956                 case FETCH:
4957                 case FINAL:
4958                 case FLOAT:
4959                 case FOR:
4960                 case FORALL:
4961                 case FORCE:
4962                 case FROM:
4963                 case FUNCTION:
4964                 case GLOBAL:
4965                 case GOTO:
4966                 case GROUP:
4967                 case HASH:
4968                 case HAVING:
4969                 case HEAP:
4970                 case HOUR:
4971                 case IF:
4972                 case IMMEDIATE:
4973                 case IN:
4974                 case INDEX:
4975                 case INDICES:
4976                 case INDEXTYPE:
4977                 case INDICATOR:
4978                 case INSERT:
4979                 case INSTANTIABLE:
4980                 case INTEGER:
4981                 case INTERFACE:
4982                 case INTERSECT:
4983                 case INTERVAL:
4984                 case INTO:
4985                 case INVALIDATE:
4986                 case IS:
4987                 case ISOLATION:
4988                 case JAVA:
4989                 case LEVEL:
4990                 case LIKE:
4991                 case LIMIT:
4992                 case LIMITED:
4993                 case LOCK:
4994                 case LONG:
4995                 case LOOP:
4996                 case MAP:
4997                 case MAX:
4998                 case MEMBER:
4999                 case MERGE:
5000                 case MIN:
5001                 case MINUS:
5002                 case MINUTE:
5003                 case MLSLABEL:
5004                 case MODIFY:
5005                 case MOD:
5006                 case MODE:
5007                 case MONTH:
5008                 case NATURAL:
5009                 case NATURALN:
5010                 case NEW:
5011                 case NEXTVAL:
5012                 case NO:
5013                 case NOCOPY:
5014                 case NONEDITIONABLE:
5015                 case NOT:
5016                 case NOWAIT:
5017                 case NULL:
5018                 case NULLIF:
5019                 case NUMBER:
5020                 case BFILE_BASE:
5021                 case BLOB_BASE:
5022                 case CLOB_BASE:
5023                 case DATE_BASE:
5024                 case NUMBER_BASE:
5025                 case OBJECT:
5026                 case OCIROWID:
5027                 case OF:
5028                 case OID:
5029                 case ON:
5030                 case OPAQUE:
5031                 case OPEN:
5032                 case OPERATOR:
5033                 case OPTION:
5034                 case OR:
5035                 case ORDER:
5036                 case ORGANIZATION:
5037                 case OTHERS:
5038                 case OUT:
5039                 case OVERRIDING:
5040                 case PACKAGE:
5041                 case PARTITION:
5042                 case PCTFREE:
5043                 case PLS_INTEGER:
5044                 case POSITIVE:
5045                 case POSITIVEN:
5046                 case PRESERVE:
5047                 case PRIOR:
5048                 case PROMPT:
5049                 case PRIVATE:
5050                 case PROCEDURE:
5051                 case PUBLIC:
5052                 case RAISE:
5053                 case RANGE:
5054                 case RAW:
5055                 case REAL:
5056                 case RECORD:
5057                 case REF:
5058                 case RELEASE:
5059                 case RELIES_ON:
5060                 case RENAME:
5061                 case RESULT:
5062                 case RETURN:
5063                 case RETURNING:
5064                 case REVERSE:
5065                 case ROLLBACK:
5066                 case ROW:
5067                 case ROWS:
5068                 case ROWID:
5069                 case ROWNUM:
5070                 case ROWTYPE:
5071                 case SAVE:
5072                 case SAVEPOINT:
5073                 case SECOND:
5074                 case SELECT:
5075                 case SELF:
5076                 case SEPARATE:
5077                 case SET:
5078                 case SHARE:
5079                 case SMALLINT:
5080                 case SPACE:
5081                 case SQL:
5082                 case SQLCODE:
5083                 case SQLERRM:
5084                 case START:
5085                 case STATIC:
5086                 case STDDEV:
5087                 case SUBTYPE:
5088                 case SUBSTITUTABLE:
5089                 case SUCCESSFUL:
5090                 case SUM:
5091                 case SYNONYM:
5092                 case SYSDATE:
5093                 case SYS_REFCURSOR:
5094                 case TABLE:
5095                 case TEMPORARY:
5096                 case THEN:
5097                 case TIME:
5098                 case TIMESTAMP:
5099                 case TIMEZONE_REGION:
5100                 case TIMEZONE_ABBR:
5101                 case TIMEZONE_MINUTE:
5102                 case TIMEZONE_HOUR:
5103                 case TO:
5104                 case TRANSACTION:
5105                 case TRIGGER:
5106                 case TRUE:
5107                 case TYPE:
5108                 case UI:
5109                 case UNDER:
5110                 case USING:
5111                 case WHILE:
5112                 case YES:
5113                 case SHOW:
5114                 case A:
5115                 case UPDATE:
5116                 case VARCHAR:
5117                 case VARCHAR2:
5118                 case DOUBLE:
5119                 case DEC:
5120                 case PRECISION:
5121                 case INT:
5122                 case NUMERIC:
5123                 case SIGNTYPE:
5124                 case NCHAR:
5125                 case NVARCHAR2:
5126                 case STRING:
5127                 case UROWID:
5128                 case VARRAY:
5129                 case VARYING:
5130                 case BFILE:
5131                 case BLOB:
5132                 case CLOB:
5133                 case NCLOB:
5134                 case YEAR:
5135                 case LOCAL:
5136                 case WITH:
5137                 case ZONE:
5138                 case CHARACTER:
5139                 case AFTER:
5140                 case BEFORE:
5141                 case OLD:
5142                 case PARENT:
5143                 case ANALYZE:
5144                 case ASSOCIATE:
5145                 case AUDIT:
5146                 case COMPOUND:
5147                 case DATABASE:
5148                 case CALL:
5149                 case DDL:
5150                 case DISASSOCIATE:
5151                 case EACH:
5152                 case FOLLOWS:
5153                 case LOGOFF:
5154                 case LOGON:
5155                 case NESTED:
5156                 case NOAUDIT:
5157                 case SCHEMA:
5158                 case SERVERERROR:
5159                 case SHUTDOWN:
5160                 case STARTUP:
5161                 case STATEMENT:
5162                 case STATISTICS:
5163                 case SUSPEND:
5164                 case TRUNCATE:
5165                 case WRAPPED:
5166                 case LIBRARY:
5167                 case NAME:
5168                 case STRUCT:
5169                 case CONTEXT:
5170                 case PARAMETERS:
5171                 case LENGTH:
5172                 case TDO:
5173                 case MAXLEN:
5174                 case CHARSETID:
5175                 case CHARSETFORM:
5176                 case ACCEPT:
5177                 case ACCESSIBLE:
5178                 case COPY:
5179                 case DEFINE:
5180                 case DISCONNECT:
5181                 case HOST:
5182                 case PRINT:
5183                 case QUIT:
5184                 case REMARK:
5185                 case UNDEFINE:
5186                 case VARIABLE:
5187                 case WHENEVER:
5188                 case ATTACH:
5189                 case CAST:
5190                 case TREAT:
5191                 case TRIM:
5192                 case LEFT:
5193                 case RIGHT:
5194                 case BOTH:
5195                 case EMPTY:
5196                 case MULTISET:
5197                 case SUBMULTISET:
5198                 case LEADING:
5199                 case TRAILING:
5200                 case CHAR_CS:
5201                 case NCHAR_CS:
5202                 case DBTIMEZONE:
5203                 case SESSIONTIMEZONE:
5204                 case AUTHENTICATED:
5205                 case LINK:
5206                 case SHARED:
5207                 case DIRECTORY:
5208                 case USER:
5209                 case IDENTIFIER:
5210                 case QUOTED_LITERAL:
5211                 case SQLDATA_CLASS:
5212                 case CUSTOMDATUM_CLASS:
5213                 case ORADATA_CLASS:
5214                 case JAVA_INTERFACE_CLASS:
5215                   ID();
5216                   break;
5217                 default:
5218                   jj_la1[53] = jj_gen;
5219                   ;
5220                 }
5221                 jj_consume_token(BY);
5222                 jj_consume_token(5);
5223                 ID();
5224                 label_14:
5225                 while (true) {
5226                   switch (jj_nt.kind) {
5227                   case 6:
5228                     ;
5229                     break;
5230                   default:
5231                     jj_la1[54] = jj_gen;
5232                     break label_14;
5233                   }
5234                   jj_consume_token(6);
5235                   ID();
5236                 }
5237                 jj_consume_token(7);
5238                 break;
5239               default:
5240                 jj_la1[55] = jj_gen;
5241                 jj_consume_token(-1);
5242                 throw new ParseException();
5243               }
5244               break;
5245             default:
5246               jj_la1[56] = jj_gen;
5247               ;
5248             }
5249             break;
5250           case RESULT_CACHE:
5251             jj_consume_token(RESULT_CACHE);
5252             switch (jj_nt.kind) {
5253             case RELIES_ON:
5254               jj_consume_token(RELIES_ON);
5255               jj_consume_token(5);
5256               ID();
5257               switch (jj_nt.kind) {
5258               case 3:
5259                 jj_consume_token(3);
5260                 ID();
5261                 break;
5262               default:
5263                 jj_la1[57] = jj_gen;
5264                 ;
5265               }
5266               label_15:
5267               while (true) {
5268                 switch (jj_nt.kind) {
5269                 case 6:
5270                   ;
5271                   break;
5272                 default:
5273                   jj_la1[58] = jj_gen;
5274                   break label_15;
5275                 }
5276                 jj_consume_token(6);
5277                 ID();
5278                 switch (jj_nt.kind) {
5279                 case 3:
5280                   jj_consume_token(3);
5281                   ID();
5282                   break;
5283                 default:
5284                   jj_la1[59] = jj_gen;
5285                   ;
5286                 }
5287               }
5288               jj_consume_token(7);
5289               break;
5290             default:
5291               jj_la1[60] = jj_gen;
5292               ;
5293             }
5294             break;
5295           default:
5296             jj_la1[61] = jj_gen;
5297             jj_consume_token(-1);
5298             throw new ParseException();
5299           }
5300         }
5301         switch (jj_nt.kind) {
5302         case AGGREGATE:
5303           jj_consume_token(AGGREGATE);
5304           jj_consume_token(USING);
5305           ID();
5306           break;
5307         default:
5308           jj_la1[62] = jj_gen;
5309           ;
5310         }
5311         switch (jj_nt.kind) {
5312         case AS:
5313         case IS:
5314           switch (jj_nt.kind) {
5315           case IS:
5316             jj_consume_token(IS);
5317             break;
5318           case AS:
5319             jj_consume_token(AS);
5320             break;
5321           default:
5322             jj_la1[63] = jj_gen;
5323             jj_consume_token(-1);
5324             throw new ParseException();
5325           }
5326           if (jj_2_21(2)) {
5327             CallSpecTail();
5328           } else {
5329             switch (jj_nt.kind) {
5330             case REPLACE:
5331             case DEFINER:
5332             case CURRENT_USER:
5333             case SERIALLY_REUSABLE:
5334             case RESTRICT_REFERENCES:
5335             case EXCEPTION_INIT:
5336             case AUTONOMOUS_TRANSACTION:
5337             case LANGUAGE:
5338             case INLINE:
5339             case ADD:
5340             case AGGREGATE:
5341             case ALL:
5342             case ALTER:
5343             case AND:
5344             case ANY:
5345             case ARRAY:
5346             case AS:
5347             case ASC:
5348             case AT:
5349             case ATTRIBUTE:
5350             case AUTHID:
5351             case AVG:
5352             case BEGIN:
5353             case BETWEEN:
5354             case BINARY_INTEGER:
5355             case BODY:
5356             case BOOLEAN:
5357             case BULK:
5358             case BY:
5359             case BYTE:
5360             case CASCADE:
5361             case CASE:
5362             case CHAR:
5363             case CHAR_BASE:
5364             case CHECK:
5365             case CLOSE:
5366             case CLUSTER:
5367             case COALESCE:
5368             case COLLECT:
5369             case COLUMN:
5370             case COMMENT:
5371             case COMMIT:
5372             case COMPRESS:
5373             case CONNECT:
5374             case CONSTANT:
5375             case CONSTRUCTOR:
5376             case CONTINUE:
5377             case CONVERT:
5378             case CREATE:
5379             case CURRENT:
5380             case CURRVAL:
5381             case CURSOR:
5382             case DATA:
5383             case DATE:
5384             case DAY:
5385             case DECLARE:
5386             case DECIMAL:
5387             case _DEFAULT:
5388             case DELETE:
5389             case DESC:
5390             case DISABLE:
5391             case DISTINCT:
5392             case DO:
5393             case DROP:
5394             case EDITIONABLE:
5395             case ELEMENT:
5396             case ELSE:
5397             case ELSIF:
5398             case ENABLE:
5399             case ESCAPE:
5400             case EXCEPT:
5401             case EXCEPTION:
5402             case EXCEPTIONS:
5403             case EXCLUSIVE:
5404             case EXECUTE:
5405             case EXISTS:
5406             case EXIT:
5407             case EXTERNAL:
5408             case EXTENDS:
5409             case EXTRACT:
5410             case FALSE:
5411             case FETCH:
5412             case FINAL:
5413             case FLOAT:
5414             case FOR:
5415             case FORALL:
5416             case FORCE:
5417             case FROM:
5418             case FUNCTION:
5419             case GLOBAL:
5420             case GOTO:
5421             case GROUP:
5422             case HASH:
5423             case HAVING:
5424             case HEAP:
5425             case HOUR:
5426             case IF:
5427             case IMMEDIATE:
5428             case IN:
5429             case INDEX:
5430             case INDICES:
5431             case INDEXTYPE:
5432             case INDICATOR:
5433             case INSERT:
5434             case INSTANTIABLE:
5435             case INTEGER:
5436             case INTERFACE:
5437             case INTERSECT:
5438             case INTERVAL:
5439             case INTO:
5440             case INVALIDATE:
5441             case IS:
5442             case ISOLATION:
5443             case JAVA:
5444             case LEVEL:
5445             case LIKE:
5446             case LIMIT:
5447             case LIMITED:
5448             case LOCK:
5449             case LONG:
5450             case LOOP:
5451             case MAP:
5452             case MAX:
5453             case MEMBER:
5454             case MERGE:
5455             case MIN:
5456             case MINUS:
5457             case MINUTE:
5458             case MLSLABEL:
5459             case MODIFY:
5460             case MOD:
5461             case MODE:
5462             case MONTH:
5463             case NATURAL:
5464             case NATURALN:
5465             case NEW:
5466             case NEXTVAL:
5467             case NO:
5468             case NOCOPY:
5469             case NONEDITIONABLE:
5470             case NOT:
5471             case NOWAIT:
5472             case NULL:
5473             case NULLIF:
5474             case NUMBER:
5475             case BFILE_BASE:
5476             case BLOB_BASE:
5477             case CLOB_BASE:
5478             case DATE_BASE:
5479             case NUMBER_BASE:
5480             case OBJECT:
5481             case OCIROWID:
5482             case OF:
5483             case OID:
5484             case ON:
5485             case OPAQUE:
5486             case OPEN:
5487             case OPERATOR:
5488             case OPTION:
5489             case OR:
5490             case ORDER:
5491             case ORGANIZATION:
5492             case OTHERS:
5493             case OUT:
5494             case OVERRIDING:
5495             case PACKAGE:
5496             case PARTITION:
5497             case PCTFREE:
5498             case PLS_INTEGER:
5499             case POSITIVE:
5500             case POSITIVEN:
5501             case PRAGMA:
5502             case PRESERVE:
5503             case PRIOR:
5504             case PROMPT:
5505             case PRIVATE:
5506             case PROCEDURE:
5507             case PUBLIC:
5508             case RAISE:
5509             case RANGE:
5510             case RAW:
5511             case REAL:
5512             case RECORD:
5513             case REF:
5514             case RELEASE:
5515             case RELIES_ON:
5516             case RENAME:
5517             case RESULT:
5518             case RETURN:
5519             case RETURNING:
5520             case REVERSE:
5521             case ROLLBACK:
5522             case ROW:
5523             case ROWS:
5524             case ROWID:
5525             case ROWNUM:
5526             case ROWTYPE:
5527             case SAVE:
5528             case SAVEPOINT:
5529             case SECOND:
5530             case SELECT:
5531             case SELF:
5532             case SEPARATE:
5533             case SET:
5534             case SHARE:
5535             case SMALLINT:
5536             case SPACE:
5537             case SQL:
5538             case SQLCODE:
5539             case SQLERRM:
5540             case START:
5541             case STATIC:
5542             case STDDEV:
5543             case SUBTYPE:
5544             case SUBSTITUTABLE:
5545             case SUCCESSFUL:
5546             case SUM:
5547             case SYNONYM:
5548             case SYSDATE:
5549             case SYS_REFCURSOR:
5550             case TABLE:
5551             case TEMPORARY:
5552             case THEN:
5553             case TIME:
5554             case TIMESTAMP:
5555             case TIMEZONE_REGION:
5556             case TIMEZONE_ABBR:
5557             case TIMEZONE_MINUTE:
5558             case TIMEZONE_HOUR:
5559             case TO:
5560             case TRANSACTION:
5561             case TRIGGER:
5562             case TRUE:
5563             case TYPE:
5564             case UI:
5565             case UNDER:
5566             case USING:
5567             case WHILE:
5568             case YES:
5569             case SHOW:
5570             case A:
5571             case UPDATE:
5572             case VARCHAR:
5573             case VARCHAR2:
5574             case DOUBLE:
5575             case DEC:
5576             case PRECISION:
5577             case INT:
5578             case NUMERIC:
5579             case SIGNTYPE:
5580             case NCHAR:
5581             case NVARCHAR2:
5582             case STRING:
5583             case UROWID:
5584             case VARRAY:
5585             case VARYING:
5586             case BFILE:
5587             case BLOB:
5588             case CLOB:
5589             case NCLOB:
5590             case YEAR:
5591             case LOCAL:
5592             case WITH:
5593             case ZONE:
5594             case CHARACTER:
5595             case AFTER:
5596             case BEFORE:
5597             case OLD:
5598             case PARENT:
5599             case CC_IF:
5600             case ANALYZE:
5601             case ASSOCIATE:
5602             case AUDIT:
5603             case COMPOUND:
5604             case DATABASE:
5605             case CALL:
5606             case DDL:
5607             case DISASSOCIATE:
5608             case EACH:
5609             case FOLLOWS:
5610             case LOGOFF:
5611             case LOGON:
5612             case NESTED:
5613             case NOAUDIT:
5614             case SCHEMA:
5615             case SERVERERROR:
5616             case SHUTDOWN:
5617             case STARTUP:
5618             case STATEMENT:
5619             case STATISTICS:
5620             case SUSPEND:
5621             case TRUNCATE:
5622             case WRAPPED:
5623             case LIBRARY:
5624             case NAME:
5625             case STRUCT:
5626             case CONTEXT:
5627             case PARAMETERS:
5628             case LENGTH:
5629             case TDO:
5630             case MAXLEN:
5631             case CHARSETID:
5632             case CHARSETFORM:
5633             case ACCEPT:
5634             case ACCESSIBLE:
5635             case COPY:
5636             case DEFINE:
5637             case DISCONNECT:
5638             case HOST:
5639             case PRINT:
5640             case QUIT:
5641             case REMARK:
5642             case UNDEFINE:
5643             case VARIABLE:
5644             case WHENEVER:
5645             case ATTACH:
5646             case CAST:
5647             case TREAT:
5648             case TRIM:
5649             case LEFT:
5650             case RIGHT:
5651             case BOTH:
5652             case EMPTY:
5653             case MULTISET:
5654             case SUBMULTISET:
5655             case LEADING:
5656             case TRAILING:
5657             case CHAR_CS:
5658             case NCHAR_CS:
5659             case DBTIMEZONE:
5660             case SESSIONTIMEZONE:
5661             case AUTHENTICATED:
5662             case LINK:
5663             case SHARED:
5664             case DIRECTORY:
5665             case USER:
5666             case IDENTIFIER:
5667             case QUOTED_LITERAL:
5668             case SQLDATA_CLASS:
5669             case CUSTOMDATUM_CLASS:
5670             case ORADATA_CLASS:
5671             case JAVA_INTERFACE_CLASS:
5672               DeclarativeSection();
5673               jj_consume_token(BEGIN);
5674               switch (jj_nt.kind) {
5675               case PRAGMA:
5676                 Pragma();
5677                 break;
5678               default:
5679                 jj_la1[64] = jj_gen;
5680                 ;
5681               }
5682               label_16:
5683               while (true) {
5684                 switch (jj_nt.kind) {
5685                 case 5:
5686                 case 16:
5687                 case 17:
5688                 case 21:
5689                 case REPLACE:
5690                 case DEFINER:
5691                 case CURRENT_USER:
5692                 case LANGUAGE:
5693                 case INLINE:
5694                 case ADD:
5695                 case AGGREGATE:
5696                 case ARRAY:
5697                 case AT:
5698                 case ATTRIBUTE:
5699                 case AUTHID:
5700                 case BEGIN:
5701                 case BODY:
5702                 case BULK:
5703                 case BYTE:
5704                 case CASCADE:
5705                 case CASE:
5706                 case CLOSE:
5707                 case COALESCE:
5708                 case COLLECT:
5709                 case COLUMN:
5710                 case COMMENT:
5711                 case COMMIT:
5712                 case CONSTRUCTOR:
5713                 case CONTINUE:
5714                 case CONVERT:
5715                 case CURRENT:
5716                 case CURSOR:
5717                 case DATA:
5718                 case DATE:
5719                 case DAY:
5720                 case DECLARE:
5721                 case DELETE:
5722                 case DISABLE:
5723                 case EDITIONABLE:
5724                 case ELEMENT:
5725                 case ENABLE:
5726                 case ESCAPE:
5727                 case EXCEPT:
5728                 case EXCEPTIONS:
5729                 case EXECUTE:
5730                 case EXIT:
5731                 case EXTERNAL:
5732                 case EXTENDS:
5733                 case EXTRACT:
5734                 case FALSE:
5735                 case FETCH:
5736                 case FINAL:
5737                 case FOR:
5738                 case FORALL:
5739                 case FORCE:
5740                 case FUNCTION:
5741                 case GLOBAL:
5742                 case GOTO:
5743                 case HASH:
5744                 case HEAP:
5745                 case HOUR:
5746                 case IF:
5747                 case IMMEDIATE:
5748                 case INDICES:
5749                 case INDEXTYPE:
5750                 case INDICATOR:
5751                 case INSERT:
5752                 case INSTANTIABLE:
5753                 case INTERVAL:
5754                 case INVALIDATE:
5755                 case ISOLATION:
5756                 case JAVA:
5757                 case LEVEL:
5758                 case LIMIT:
5759                 case LOCK:
5760                 case LOOP:
5761                 case MAP:
5762                 case MAX:
5763                 case MEMBER:
5764                 case MERGE:
5765                 case MIN:
5766                 case MINUTE:
5767                 case MLSLABEL:
5768                 case MODIFY:
5769                 case MOD:
5770                 case MONTH:
5771                 case NATURAL:
5772                 case NEW:
5773                 case NEW_DOT:
5774                 case NO:
5775                 case NONEDITIONABLE:
5776                 case NOT:
5777                 case NULL:
5778                 case NULLIF:
5779                 case OBJECT:
5780                 case OID:
5781                 case OPAQUE:
5782                 case OPEN:
5783                 case OPERATOR:
5784                 case ORGANIZATION:
5785                 case OTHERS:
5786                 case OVERRIDING:
5787                 case PACKAGE:
5788                 case PARTITION:
5789                 case PIPE:
5790                 case PRAGMA:
5791                 case PRESERVE:
5792                 case PRIVATE:
5793                 case PROCEDURE:
5794                 case RAISE:
5795                 case RANGE:
5796                 case RAW:
5797                 case REAL:
5798                 case RECORD:
5799                 case REF:
5800                 case RELEASE:
5801                 case RELIES_ON:
5802                 case RENAME:
5803                 case RESULT:
5804                 case RETURN:
5805                 case RETURNING:
5806                 case REVERSE:
5807                 case ROLLBACK:
5808                 case ROW:
5809                 case ROWS:
5810                 case ROWID:
5811                 case ROWNUM:
5812                 case SAVE:
5813                 case SAVEPOINT:
5814                 case SECOND:
5815                 case SELECT:
5816                 case SELF:
5817                 case SET:
5818                 case SPACE:
5819                 case SQL:
5820                 case SQLCODE:
5821                 case SQLERRM:
5822                 case STATIC:
5823                 case SUBTYPE:
5824                 case SUBSTITUTABLE:
5825                 case SUCCESSFUL:
5826                 case SYSDATE:
5827                 case SYS_REFCURSOR:
5828                 case TEMPORARY:
5829                 case TIME:
5830                 case TIMESTAMP:
5831                 case TIMEZONE_REGION:
5832                 case TIMEZONE_ABBR:
5833                 case TIMEZONE_MINUTE:
5834                 case TIMEZONE_HOUR:
5835                 case TRANSACTION:
5836                 case TRUE:
5837                 case TYPE:
5838                 case UNDER:
5839                 case USING:
5840                 case WHILE:
5841                 case YES:
5842                 case SHOW:
5843                 case A:
5844                 case UPDATE:
5845                 case DOUBLE:
5846                 case DEC:
5847                 case PRECISION:
5848                 case INT:
5849                 case NUMERIC:
5850                 case NCHAR:
5851                 case NVARCHAR2:
5852                 case STRING:
5853                 case UROWID:
5854                 case VARRAY:
5855                 case VARYING:
5856                 case BFILE:
5857                 case BLOB:
5858                 case CLOB:
5859                 case NCLOB:
5860                 case YEAR:
5861                 case LOCAL:
5862                 case WITH:
5863                 case ZONE:
5864                 case CHARACTER:
5865                 case AFTER:
5866                 case BEFORE:
5867                 case OLD:
5868                 case PARENT:
5869                 case CC_IF:
5870                 case CC_ERROR:
5871                 case ANALYZE:
5872                 case ASSOCIATE:
5873                 case AUDIT:
5874                 case COMPOUND:
5875                 case DATABASE:
5876                 case CALL:
5877                 case DDL:
5878                 case DISASSOCIATE:
5879                 case EACH:
5880                 case FOLLOWS:
5881                 case LOGOFF:
5882                 case LOGON:
5883                 case NESTED:
5884                 case NOAUDIT:
5885                 case SCHEMA:
5886                 case SERVERERROR:
5887                 case SHUTDOWN:
5888                 case STARTUP:
5889                 case STATEMENT:
5890                 case STATISTICS:
5891                 case SUSPEND:
5892                 case TRUNCATE:
5893                 case WRAPPED:
5894                 case LIBRARY:
5895                 case NAME:
5896                 case STRUCT:
5897                 case CONTEXT:
5898                 case PARAMETERS:
5899                 case LENGTH:
5900                 case TDO:
5901                 case MAXLEN:
5902                 case CHARSETID:
5903                 case CHARSETFORM:
5904                 case ACCEPT:
5905                 case ACCESSIBLE:
5906                 case COPY:
5907                 case DEFINE:
5908                 case DISCONNECT:
5909                 case HOST:
5910                 case PRINT:
5911                 case QUIT:
5912                 case REMARK:
5913                 case UNDEFINE:
5914                 case VARIABLE:
5915                 case WHENEVER:
5916                 case ATTACH:
5917                 case CAST:
5918                 case TREAT:
5919                 case TRIM:
5920                 case LEFT:
5921                 case RIGHT:
5922                 case BOTH:
5923                 case EMPTY:
5924                 case MULTISET:
5925                 case SUBMULTISET:
5926                 case LEADING:
5927                 case TRAILING:
5928                 case CHAR_CS:
5929                 case NCHAR_CS:
5930                 case DBTIMEZONE:
5931                 case SESSIONTIMEZONE:
5932                 case AUTHENTICATED:
5933                 case LINK:
5934                 case SHARED:
5935                 case DIRECTORY:
5936                 case USER:
5937                 case IDENTIFIER:
5938                 case UNSIGNED_NUMERIC_LITERAL:
5939                 case CHARACTER_LITERAL:
5940                 case STRING_LITERAL:
5941                 case QUOTED_LITERAL:
5942                   ;
5943                   break;
5944                 default:
5945                   jj_la1[65] = jj_gen;
5946                   break label_16;
5947                 }
5948                 Statement();
5949               }
5950               switch (jj_nt.kind) {
5951               case EXCEPTION:
5952                 ExceptionHandler();
5953                 break;
5954               default:
5955                 jj_la1[66] = jj_gen;
5956                 ;
5957               }
5958               jj_consume_token(END);
5959               switch (jj_nt.kind) {
5960               case REPLACE:
5961               case DEFINER:
5962               case CURRENT_USER:
5963               case SERIALLY_REUSABLE:
5964               case RESTRICT_REFERENCES:
5965               case EXCEPTION_INIT:
5966               case AUTONOMOUS_TRANSACTION:
5967               case LANGUAGE:
5968               case INLINE:
5969               case ADD:
5970               case AGGREGATE:
5971               case ALL:
5972               case ALTER:
5973               case AND:
5974               case ANY:
5975               case ARRAY:
5976               case AS:
5977               case ASC:
5978               case AT:
5979               case ATTRIBUTE:
5980               case AUTHID:
5981               case AVG:
5982               case BETWEEN:
5983               case BINARY_INTEGER:
5984               case BODY:
5985               case BOOLEAN:
5986               case BULK:
5987               case BY:
5988               case BYTE:
5989               case CASCADE:
5990               case CASE:
5991               case CHAR:
5992               case CHAR_BASE:
5993               case CHECK:
5994               case CLOSE:
5995               case CLUSTER:
5996               case COALESCE:
5997               case COLLECT:
5998               case COLUMN:
5999               case COMMENT:
6000               case COMMIT:
6001               case COMPRESS:
6002               case CONNECT:
6003               case CONSTANT:
6004               case CONSTRUCTOR:
6005               case CONTINUE:
6006               case CONVERT:
6007               case CREATE:
6008               case CURRENT:
6009               case CURRVAL:
6010               case CURSOR:
6011               case DATA:
6012               case DATE:
6013               case DAY:
6014               case DECLARE:
6015               case DECIMAL:
6016               case _DEFAULT:
6017               case DELETE:
6018               case DESC:
6019               case DISABLE:
6020               case DISTINCT:
6021               case DO:
6022               case DROP:
6023               case EDITIONABLE:
6024               case ELEMENT:
6025               case ELSE:
6026               case ELSIF:
6027               case ENABLE:
6028               case ESCAPE:
6029               case EXCEPT:
6030               case EXCEPTION:
6031               case EXCEPTIONS:
6032               case EXCLUSIVE:
6033               case EXECUTE:
6034               case EXISTS:
6035               case EXIT:
6036               case EXTERNAL:
6037               case EXTENDS:
6038               case EXTRACT:
6039               case FALSE:
6040               case FETCH:
6041               case FINAL:
6042               case FLOAT:
6043               case FOR:
6044               case FORALL:
6045               case FORCE:
6046               case FROM:
6047               case FUNCTION:
6048               case GLOBAL:
6049               case GOTO:
6050               case GROUP:
6051               case HASH:
6052               case HAVING:
6053               case HEAP:
6054               case HOUR:
6055               case IF:
6056               case IMMEDIATE:
6057               case IN:
6058               case INDEX:
6059               case INDICES:
6060               case INDEXTYPE:
6061               case INDICATOR:
6062               case INSERT:
6063               case INSTANTIABLE:
6064               case INTEGER:
6065               case INTERFACE:
6066               case INTERSECT:
6067               case INTERVAL:
6068               case INTO:
6069               case INVALIDATE:
6070               case IS:
6071               case ISOLATION:
6072               case JAVA:
6073               case LEVEL:
6074               case LIKE:
6075               case LIMIT:
6076               case LIMITED:
6077               case LOCK:
6078               case LONG:
6079               case LOOP:
6080               case MAP:
6081               case MAX:
6082               case MEMBER:
6083               case MERGE:
6084               case MIN:
6085               case MINUS:
6086               case MINUTE:
6087               case MLSLABEL:
6088               case MODIFY:
6089               case MOD:
6090               case MODE:
6091               case MONTH:
6092               case NATURAL:
6093               case NATURALN:
6094               case NEW:
6095               case NEXTVAL:
6096               case NO:
6097               case NOCOPY:
6098               case NONEDITIONABLE:
6099               case NOT:
6100               case NOWAIT:
6101               case NULL:
6102               case NULLIF:
6103               case NUMBER:
6104               case BFILE_BASE:
6105               case BLOB_BASE:
6106               case CLOB_BASE:
6107               case DATE_BASE:
6108               case NUMBER_BASE:
6109               case OBJECT:
6110               case OCIROWID:
6111               case OF:
6112               case OID:
6113               case ON:
6114               case OPAQUE:
6115               case OPEN:
6116               case OPERATOR:
6117               case OPTION:
6118               case OR:
6119               case ORDER:
6120               case ORGANIZATION:
6121               case OTHERS:
6122               case OUT:
6123               case OVERRIDING:
6124               case PACKAGE:
6125               case PARTITION:
6126               case PCTFREE:
6127               case PLS_INTEGER:
6128               case POSITIVE:
6129               case POSITIVEN:
6130               case PRESERVE:
6131               case PRIOR:
6132               case PROMPT:
6133               case PRIVATE:
6134               case PROCEDURE:
6135               case PUBLIC:
6136               case RAISE:
6137               case RANGE:
6138               case RAW:
6139               case REAL:
6140               case RECORD:
6141               case REF:
6142               case RELEASE:
6143               case RELIES_ON:
6144               case RENAME:
6145               case RESULT:
6146               case RETURN:
6147               case RETURNING:
6148               case REVERSE:
6149               case ROLLBACK:
6150               case ROW:
6151               case ROWS:
6152               case ROWID:
6153               case ROWNUM:
6154               case ROWTYPE:
6155               case SAVE:
6156               case SAVEPOINT:
6157               case SECOND:
6158               case SELECT:
6159               case SELF:
6160               case SEPARATE:
6161               case SET:
6162               case SHARE:
6163               case SMALLINT:
6164               case SPACE:
6165               case SQL:
6166               case SQLCODE:
6167               case SQLERRM:
6168               case START:
6169               case STATIC:
6170               case STDDEV:
6171               case SUBTYPE:
6172               case SUBSTITUTABLE:
6173               case SUCCESSFUL:
6174               case SUM:
6175               case SYNONYM:
6176               case SYSDATE:
6177               case SYS_REFCURSOR:
6178               case TABLE:
6179               case TEMPORARY:
6180               case THEN:
6181               case TIME:
6182               case TIMESTAMP:
6183               case TIMEZONE_REGION:
6184               case TIMEZONE_ABBR:
6185               case TIMEZONE_MINUTE:
6186               case TIMEZONE_HOUR:
6187               case TO:
6188               case TRANSACTION:
6189               case TRIGGER:
6190               case TRUE:
6191               case TYPE:
6192               case UI:
6193               case UNDER:
6194               case USING:
6195               case WHILE:
6196               case YES:
6197               case SHOW:
6198               case A:
6199               case UPDATE:
6200               case VARCHAR:
6201               case VARCHAR2:
6202               case DOUBLE:
6203               case DEC:
6204               case PRECISION:
6205               case INT:
6206               case NUMERIC:
6207               case SIGNTYPE:
6208               case NCHAR:
6209               case NVARCHAR2:
6210               case STRING:
6211               case UROWID:
6212               case VARRAY:
6213               case VARYING:
6214               case BFILE:
6215               case BLOB:
6216               case CLOB:
6217               case NCLOB:
6218               case YEAR:
6219               case LOCAL:
6220               case WITH:
6221               case ZONE:
6222               case CHARACTER:
6223               case AFTER:
6224               case BEFORE:
6225               case OLD:
6226               case PARENT:
6227               case ANALYZE:
6228               case ASSOCIATE:
6229               case AUDIT:
6230               case COMPOUND:
6231               case DATABASE:
6232               case CALL:
6233               case DDL:
6234               case DISASSOCIATE:
6235               case EACH:
6236               case FOLLOWS:
6237               case LOGOFF:
6238               case LOGON:
6239               case NESTED:
6240               case NOAUDIT:
6241               case SCHEMA:
6242               case SERVERERROR:
6243               case SHUTDOWN:
6244               case STARTUP:
6245               case STATEMENT:
6246               case STATISTICS:
6247               case SUSPEND:
6248               case TRUNCATE:
6249               case WRAPPED:
6250               case LIBRARY:
6251               case NAME:
6252               case STRUCT:
6253               case CONTEXT:
6254               case PARAMETERS:
6255               case LENGTH:
6256               case TDO:
6257               case MAXLEN:
6258               case CHARSETID:
6259               case CHARSETFORM:
6260               case ACCEPT:
6261               case ACCESSIBLE:
6262               case COPY:
6263               case DEFINE:
6264               case DISCONNECT:
6265               case HOST:
6266               case PRINT:
6267               case QUIT:
6268               case REMARK:
6269               case UNDEFINE:
6270               case VARIABLE:
6271               case WHENEVER:
6272               case ATTACH:
6273               case CAST:
6274               case TREAT:
6275               case TRIM:
6276               case LEFT:
6277               case RIGHT:
6278               case BOTH:
6279               case EMPTY:
6280               case MULTISET:
6281               case SUBMULTISET:
6282               case LEADING:
6283               case TRAILING:
6284               case CHAR_CS:
6285               case NCHAR_CS:
6286               case DBTIMEZONE:
6287               case SESSIONTIMEZONE:
6288               case AUTHENTICATED:
6289               case LINK:
6290               case SHARED:
6291               case DIRECTORY:
6292               case USER:
6293               case IDENTIFIER:
6294               case QUOTED_LITERAL:
6295               case SQLDATA_CLASS:
6296               case CUSTOMDATUM_CLASS:
6297               case ORADATA_CLASS:
6298               case JAVA_INTERFACE_CLASS:
6299                 ID();
6300                 break;
6301               default:
6302                 jj_la1[67] = jj_gen;
6303                 ;
6304               }
6305               break;
6306             default:
6307               jj_la1[68] = jj_gen;
6308               jj_consume_token(-1);
6309               throw new ParseException();
6310             }
6311           }
6312           break;
6313         default:
6314           jj_la1[69] = jj_gen;
6315           ;
6316         }
6317         jj_consume_token(4);
6318         break;
6319       default:
6320         jj_la1[70] = jj_gen;
6321         jj_consume_token(-1);
6322         throw new ParseException();
6323       }
6324         jjtree.closeNodeScope(jjtn000, true);
6325         jjtc000 = false;
6326         {if (true) return jjtn000 ;}
6327     } catch (Throwable jjte000) {
6328           if (jjtc000) {
6329             jjtree.clearNodeScope(jjtn000);
6330             jjtc000 = false;
6331           } else {
6332             jjtree.popNode();
6333           }
6334           if (jjte000 instanceof RuntimeException) {
6335             {if (true) throw (RuntimeException)jjte000;}
6336           }
6337           if (jjte000 instanceof ParseException) {
6338             {if (true) throw (ParseException)jjte000;}
6339           }
6340           {if (true) throw (Error)jjte000;}
6341     } finally {
6342           if (jjtc000) {
6343             jjtree.closeNodeScope(jjtn000, true);
6344           }
6345     }
6346     throw new Error("Missing return statement in function");
6347   }
6348 
6349   final public ASTObjectNameDeclaration ObjectNameDeclaration() throws ParseException {
6350  /*@bgen(jjtree) ObjectNameDeclaration */
6351  ASTObjectNameDeclaration jjtn000 = new ASTObjectNameDeclaration(this, JJTOBJECTNAMEDECLARATION);
6352  boolean jjtc000 = true;
6353  jjtree.openNodeScope(jjtn000);PLSQLNode schemaName = null, objectName = null ;
6354     try {
6355       if (jj_2_22(2)) {
6356         schemaName = ID();
6357         jj_consume_token(3);
6358       } else {
6359         ;
6360       }
6361       objectName = ID();
6362     jjtn000.setImage(  (null == schemaName) ?  objectName.getImage() : (schemaName.getImage() + "." + objectName.getImage() )  )  ;
6363     jjtree.closeNodeScope(jjtn000, true);
6364     jjtc000 = false;
6365     {if (true) return jjtn000 ;}
6366     } catch (Throwable jjte000) {
6367     if (jjtc000) {
6368       jjtree.clearNodeScope(jjtn000);
6369       jjtc000 = false;
6370     } else {
6371       jjtree.popNode();
6372     }
6373     if (jjte000 instanceof RuntimeException) {
6374       {if (true) throw (RuntimeException)jjte000;}
6375     }
6376     if (jjte000 instanceof ParseException) {
6377       {if (true) throw (ParseException)jjte000;}
6378     }
6379     {if (true) throw (Error)jjte000;}
6380     } finally {
6381     if (jjtc000) {
6382       jjtree.closeNodeScope(jjtn000, true);
6383     }
6384     }
6385     throw new Error("Missing return statement in function");
6386   }
6387 
6388   final public ASTFormalParameter FormalParameter() throws ParseException {
6389  /*@bgen(jjtree) FormalParameter */
6390  ASTFormalParameter jjtn000 = new ASTFormalParameter(this, JJTFORMALPARAMETER);
6391  boolean jjtc000 = true;
6392  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6393     try {
6394       simpleNode = ID();
6395       if (jj_2_25(2)) {
6396         if (jj_2_24(2)) {
6397           switch (jj_nt.kind) {
6398           case OUT:
6399             jj_consume_token(OUT);
6400             break;
6401           case IN:
6402             jj_consume_token(IN);
6403             jj_consume_token(OUT);
6404             break;
6405           default:
6406             jj_la1[71] = jj_gen;
6407             jj_consume_token(-1);
6408             throw new ParseException();
6409           }
6410           if (jj_2_23(2)) {
6411             jj_consume_token(NOCOPY);
6412           } else {
6413             ;
6414           }
6415         } else {
6416           switch (jj_nt.kind) {
6417           case IN:
6418             jj_consume_token(IN);
6419             break;
6420           default:
6421             jj_la1[72] = jj_gen;
6422             jj_consume_token(-1);
6423             throw new ParseException();
6424           }
6425         }
6426       } else {
6427         ;
6428       }
6429       switch (jj_nt.kind) {
6430       case 8:
6431         jj_consume_token(8);
6432         break;
6433       case REPLACE:
6434       case DEFINER:
6435       case CURRENT_USER:
6436       case LANGUAGE:
6437       case INLINE:
6438       case ADD:
6439       case AGGREGATE:
6440       case ARRAY:
6441       case AT:
6442       case ATTRIBUTE:
6443       case AUTHID:
6444       case BINARY_INTEGER:
6445       case BODY:
6446       case BOOLEAN:
6447       case BULK:
6448       case BYTE:
6449       case CASCADE:
6450       case CHAR:
6451       case CHAR_BASE:
6452       case CLOSE:
6453       case COALESCE:
6454       case COLLECT:
6455       case COLUMN:
6456       case COMMENT:
6457       case COMMIT:
6458       case CONSTRUCTOR:
6459       case CONTINUE:
6460       case CONVERT:
6461       case CURRENT:
6462       case CURSOR:
6463       case DATA:
6464       case DATE:
6465       case DAY:
6466       case DECIMAL:
6467       case DISABLE:
6468       case EDITIONABLE:
6469       case ELEMENT:
6470       case ENABLE:
6471       case ESCAPE:
6472       case EXCEPT:
6473       case EXCEPTIONS:
6474       case EXIT:
6475       case EXTERNAL:
6476       case EXTENDS:
6477       case EXTRACT:
6478       case FALSE:
6479       case FINAL:
6480       case FLOAT:
6481       case FORCE:
6482       case FUNCTION:
6483       case GLOBAL:
6484       case HASH:
6485       case HEAP:
6486       case HOUR:
6487       case IMMEDIATE:
6488       case INDICES:
6489       case INDEXTYPE:
6490       case INDICATOR:
6491       case INSTANTIABLE:
6492       case INTEGER:
6493       case INTERVAL:
6494       case INVALIDATE:
6495       case ISOLATION:
6496       case JAVA:
6497       case LEVEL:
6498       case LIMIT:
6499       case LONG:
6500       case LOOP:
6501       case MAP:
6502       case MAX:
6503       case MEMBER:
6504       case MERGE:
6505       case MIN:
6506       case MINUTE:
6507       case MLSLABEL:
6508       case MODIFY:
6509       case MOD:
6510       case MONTH:
6511       case NATURAL:
6512       case NATURALN:
6513       case NEW:
6514       case NO:
6515       case NONEDITIONABLE:
6516       case NULLIF:
6517       case NUMBER:
6518       case BFILE_BASE:
6519       case BLOB_BASE:
6520       case CLOB_BASE:
6521       case DATE_BASE:
6522       case NUMBER_BASE:
6523       case OBJECT:
6524       case OID:
6525       case OPAQUE:
6526       case OPEN:
6527       case OPERATOR:
6528       case ORGANIZATION:
6529       case OTHERS:
6530       case OVERRIDING:
6531       case PACKAGE:
6532       case PARTITION:
6533       case PLS_INTEGER:
6534       case POSITIVE:
6535       case POSITIVEN:
6536       case PRESERVE:
6537       case PRIVATE:
6538       case PROCEDURE:
6539       case RANGE:
6540       case RAW:
6541       case REAL:
6542       case RECORD:
6543       case REF:
6544       case RELEASE:
6545       case RELIES_ON:
6546       case RENAME:
6547       case RESULT:
6548       case RETURN:
6549       case RETURNING:
6550       case REVERSE:
6551       case ROLLBACK:
6552       case ROW:
6553       case ROWS:
6554       case ROWID:
6555       case ROWNUM:
6556       case SAVE:
6557       case SAVEPOINT:
6558       case SECOND:
6559       case SELF:
6560       case SET:
6561       case SMALLINT:
6562       case SPACE:
6563       case SQL:
6564       case SQLCODE:
6565       case SQLERRM:
6566       case STATIC:
6567       case SUBTYPE:
6568       case SUBSTITUTABLE:
6569       case SUCCESSFUL:
6570       case SYSDATE:
6571       case SYS_REFCURSOR:
6572       case TEMPORARY:
6573       case TIME:
6574       case TIMESTAMP:
6575       case TIMEZONE_REGION:
6576       case TIMEZONE_ABBR:
6577       case TIMEZONE_MINUTE:
6578       case TIMEZONE_HOUR:
6579       case TRANSACTION:
6580       case TRUE:
6581       case TYPE:
6582       case UNDER:
6583       case USING:
6584       case YES:
6585       case SHOW:
6586       case A:
6587       case VARCHAR:
6588       case VARCHAR2:
6589       case DOUBLE:
6590       case DEC:
6591       case PRECISION:
6592       case INT:
6593       case NUMERIC:
6594       case SIGNTYPE:
6595       case NCHAR:
6596       case NVARCHAR2:
6597       case STRING:
6598       case UROWID:
6599       case VARRAY:
6600       case VARYING:
6601       case BFILE:
6602       case BLOB:
6603       case CLOB:
6604       case NCLOB:
6605       case YEAR:
6606       case LOCAL:
6607       case ZONE:
6608       case CHARACTER:
6609       case AFTER:
6610       case BEFORE:
6611       case OLD:
6612       case PARENT:
6613       case CC_IF:
6614       case ANALYZE:
6615       case ASSOCIATE:
6616       case AUDIT:
6617       case COMPOUND:
6618       case DATABASE:
6619       case CALL:
6620       case DDL:
6621       case DISASSOCIATE:
6622       case EACH:
6623       case FOLLOWS:
6624       case LOGOFF:
6625       case LOGON:
6626       case NESTED:
6627       case NOAUDIT:
6628       case SCHEMA:
6629       case SERVERERROR:
6630       case SHUTDOWN:
6631       case STARTUP:
6632       case STATEMENT:
6633       case STATISTICS:
6634       case SUSPEND:
6635       case TRUNCATE:
6636       case WRAPPED:
6637       case LIBRARY:
6638       case NAME:
6639       case STRUCT:
6640       case CONTEXT:
6641       case PARAMETERS:
6642       case LENGTH:
6643       case TDO:
6644       case MAXLEN:
6645       case CHARSETID:
6646       case CHARSETFORM:
6647       case ACCEPT:
6648       case ACCESSIBLE:
6649       case COPY:
6650       case DEFINE:
6651       case DISCONNECT:
6652       case HOST:
6653       case PRINT:
6654       case QUIT:
6655       case REMARK:
6656       case UNDEFINE:
6657       case VARIABLE:
6658       case WHENEVER:
6659       case ATTACH:
6660       case CAST:
6661       case TREAT:
6662       case TRIM:
6663       case LEFT:
6664       case RIGHT:
6665       case BOTH:
6666       case EMPTY:
6667       case MULTISET:
6668       case SUBMULTISET:
6669       case LEADING:
6670       case TRAILING:
6671       case CHAR_CS:
6672       case NCHAR_CS:
6673       case DBTIMEZONE:
6674       case SESSIONTIMEZONE:
6675       case AUTHENTICATED:
6676       case LINK:
6677       case SHARED:
6678       case DIRECTORY:
6679       case USER:
6680       case IDENTIFIER:
6681       case QUOTED_LITERAL:
6682         Datatype();
6683         break;
6684       default:
6685         jj_la1[73] = jj_gen;
6686         jj_consume_token(-1);
6687         throw new ParseException();
6688       }
6689       switch (jj_nt.kind) {
6690       case 9:
6691       case _DEFAULT:
6692         switch (jj_nt.kind) {
6693         case 9:
6694           jj_consume_token(9);
6695           jj_consume_token(10);
6696           break;
6697         case _DEFAULT:
6698           jj_consume_token(_DEFAULT);
6699           break;
6700         default:
6701           jj_la1[74] = jj_gen;
6702           jj_consume_token(-1);
6703           throw new ParseException();
6704         }
6705         Expression();
6706         break;
6707       default:
6708         jj_la1[75] = jj_gen;
6709         ;
6710       }
6711      jjtree.closeNodeScope(jjtn000, true);
6712      jjtc000 = false;
6713      jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
6714     } catch (Throwable jjte000) {
6715      if (jjtc000) {
6716        jjtree.clearNodeScope(jjtn000);
6717        jjtc000 = false;
6718      } else {
6719        jjtree.popNode();
6720      }
6721      if (jjte000 instanceof RuntimeException) {
6722        {if (true) throw (RuntimeException)jjte000;}
6723      }
6724      if (jjte000 instanceof ParseException) {
6725        {if (true) throw (ParseException)jjte000;}
6726      }
6727      {if (true) throw (Error)jjte000;}
6728     } finally {
6729      if (jjtc000) {
6730        jjtree.closeNodeScope(jjtn000, true);
6731      }
6732     }
6733     throw new Error("Missing return statement in function");
6734   }
6735 
6736   final public ASTMethodDeclaration MethodDeclaration() throws ParseException {
6737  /*@bgen(jjtree) MethodDeclaration */
6738   ASTMethodDeclaration jjtn000 = new ASTMethodDeclaration(this, JJTMETHODDECLARATION);
6739   boolean jjtc000 = true;
6740   jjtree.openNodeScope(jjtn000);
6741     try {
6742       switch (jj_nt.kind) {
6743       case CREATE:
6744       case FUNCTION:
6745       case PROCEDURE:
6746         ProgramUnit();
6747         break;
6748       case CONSTRUCTOR:
6749       case FINAL:
6750       case INSTANTIABLE:
6751       case MAP:
6752       case MEMBER:
6753       case NOT:
6754       case ORDER:
6755       case OVERRIDING:
6756       case STATIC:
6757         TypeMethod();
6758         break;
6759       default:
6760         jj_la1[76] = jj_gen;
6761         jj_consume_token(-1);
6762         throw new ParseException();
6763       }
6764     jjtree.closeNodeScope(jjtn000, true);
6765     jjtc000 = false;
6766     {if (true) return jjtn000 ;}
6767     } catch (Throwable jjte000) {
6768     if (jjtc000) {
6769       jjtree.clearNodeScope(jjtn000);
6770       jjtc000 = false;
6771     } else {
6772       jjtree.popNode();
6773     }
6774     if (jjte000 instanceof RuntimeException) {
6775       {if (true) throw (RuntimeException)jjte000;}
6776     }
6777     if (jjte000 instanceof ParseException) {
6778       {if (true) throw (ParseException)jjte000;}
6779     }
6780     {if (true) throw (Error)jjte000;}
6781     } finally {
6782     if (jjtc000) {
6783       jjtree.closeNodeScope(jjtn000, true);
6784     }
6785     }
6786     throw new Error("Missing return statement in function");
6787   }
6788 
6789   final public ASTMethodDeclarator MethodDeclarator() throws ParseException {
6790  /*@bgen(jjtree) MethodDeclarator */
6791  ASTMethodDeclarator jjtn000 = new ASTMethodDeclarator(this, JJTMETHODDECLARATOR);
6792  boolean jjtc000 = true;
6793  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6794     try {
6795       switch (jj_nt.kind) {
6796       case FUNCTION:
6797         jj_consume_token(FUNCTION);
6798         simpleNode = ObjectNameDeclaration();
6799         switch (jj_nt.kind) {
6800         case 5:
6801           FormalParameters();
6802           break;
6803         default:
6804           jj_la1[77] = jj_gen;
6805           ;
6806         }
6807         Token nextToken;
6808         nextToken = getToken(1); //ReadAhead
6809         if (!nextToken.image.equalsIgnoreCase("WRAPPED")
6810             &&
6811             !nextToken.image.equalsIgnoreCase("RETURN")
6812            )
6813         {
6814           {if (true) throw new ParseException("FUNCTION must RETURN a value or must be WRAPPED : found \u005c""
6815                                               + nextToken.image
6816                                               + "\u005c" at line "+nextToken.beginLine
6817                                               + ", column "+nextToken.beginColumn
6818                                              );}
6819         }
6820         switch (jj_nt.kind) {
6821         case RETURN:
6822           jj_consume_token(RETURN);
6823           Datatype();
6824           break;
6825         default:
6826           jj_la1[78] = jj_gen;
6827           ;
6828         }
6829         break;
6830       case PROCEDURE:
6831         jj_consume_token(PROCEDURE);
6832         simpleNode = ObjectNameDeclaration();
6833         switch (jj_nt.kind) {
6834         case 5:
6835           FormalParameters();
6836           break;
6837         default:
6838           jj_la1[79] = jj_gen;
6839           ;
6840         }
6841         break;
6842       default:
6843         jj_la1[80] = jj_gen;
6844         jj_consume_token(-1);
6845         throw new ParseException();
6846       }
6847     jjtree.closeNodeScope(jjtn000, true);
6848     jjtc000 = false;
6849     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
6850     } catch (Throwable jjte000) {
6851     if (jjtc000) {
6852       jjtree.clearNodeScope(jjtn000);
6853       jjtc000 = false;
6854     } else {
6855       jjtree.popNode();
6856     }
6857     if (jjte000 instanceof RuntimeException) {
6858       {if (true) throw (RuntimeException)jjte000;}
6859     }
6860     if (jjte000 instanceof ParseException) {
6861       {if (true) throw (ParseException)jjte000;}
6862     }
6863     {if (true) throw (Error)jjte000;}
6864     } finally {
6865     if (jjtc000) {
6866       jjtree.closeNodeScope(jjtn000, true);
6867     }
6868     }
6869     throw new Error("Missing return statement in function");
6870   }
6871 
6872   final public ASTFormalParameters FormalParameters() throws ParseException {
6873  /*@bgen(jjtree) FormalParameters */
6874  ASTFormalParameters jjtn000 = new ASTFormalParameters(this, JJTFORMALPARAMETERS);
6875  boolean jjtc000 = true;
6876  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6877  StringBuilder sb = new StringBuilder();
6878     try {
6879       jj_consume_token(5);
6880         sb.append("(");
6881       switch (jj_nt.kind) {
6882       case REPLACE:
6883       case DEFINER:
6884       case CURRENT_USER:
6885       case SERIALLY_REUSABLE:
6886       case RESTRICT_REFERENCES:
6887       case EXCEPTION_INIT:
6888       case AUTONOMOUS_TRANSACTION:
6889       case LANGUAGE:
6890       case INLINE:
6891       case ADD:
6892       case AGGREGATE:
6893       case ALL:
6894       case ALTER:
6895       case AND:
6896       case ANY:
6897       case ARRAY:
6898       case AS:
6899       case ASC:
6900       case AT:
6901       case ATTRIBUTE:
6902       case AUTHID:
6903       case AVG:
6904       case BETWEEN:
6905       case BINARY_INTEGER:
6906       case BODY:
6907       case BOOLEAN:
6908       case BULK:
6909       case BY:
6910       case BYTE:
6911       case CASCADE:
6912       case CASE:
6913       case CHAR:
6914       case CHAR_BASE:
6915       case CHECK:
6916       case CLOSE:
6917       case CLUSTER:
6918       case COALESCE:
6919       case COLLECT:
6920       case COLUMN:
6921       case COMMENT:
6922       case COMMIT:
6923       case COMPRESS:
6924       case CONNECT:
6925       case CONSTANT:
6926       case CONSTRUCTOR:
6927       case CONTINUE:
6928       case CONVERT:
6929       case CREATE:
6930       case CURRENT:
6931       case CURRVAL:
6932       case CURSOR:
6933       case DATA:
6934       case DATE:
6935       case DAY:
6936       case DECLARE:
6937       case DECIMAL:
6938       case _DEFAULT:
6939       case DELETE:
6940       case DESC:
6941       case DISABLE:
6942       case DISTINCT:
6943       case DO:
6944       case DROP:
6945       case EDITIONABLE:
6946       case ELEMENT:
6947       case ELSE:
6948       case ELSIF:
6949       case ENABLE:
6950       case ESCAPE:
6951       case EXCEPT:
6952       case EXCEPTION:
6953       case EXCEPTIONS:
6954       case EXCLUSIVE:
6955       case EXECUTE:
6956       case EXISTS:
6957       case EXIT:
6958       case EXTERNAL:
6959       case EXTENDS:
6960       case EXTRACT:
6961       case FALSE:
6962       case FETCH:
6963       case FINAL:
6964       case FLOAT:
6965       case FOR:
6966       case FORALL:
6967       case FORCE:
6968       case FROM:
6969       case FUNCTION:
6970       case GLOBAL:
6971       case GOTO:
6972       case GROUP:
6973       case HASH:
6974       case HAVING:
6975       case HEAP:
6976       case HOUR:
6977       case IF:
6978       case IMMEDIATE:
6979       case IN:
6980       case INDEX:
6981       case INDICES:
6982       case INDEXTYPE:
6983       case INDICATOR:
6984       case INSERT:
6985       case INSTANTIABLE:
6986       case INTEGER:
6987       case INTERFACE:
6988       case INTERSECT:
6989       case INTERVAL:
6990       case INTO:
6991       case INVALIDATE:
6992       case IS:
6993       case ISOLATION:
6994       case JAVA:
6995       case LEVEL:
6996       case LIKE:
6997       case LIMIT:
6998       case LIMITED:
6999       case LOCK:
7000       case LONG:
7001       case LOOP:
7002       case MAP:
7003       case MAX:
7004       case MEMBER:
7005       case MERGE:
7006       case MIN:
7007       case MINUS:
7008       case MINUTE:
7009       case MLSLABEL:
7010       case MODIFY:
7011       case MOD:
7012       case MODE:
7013       case MONTH:
7014       case NATURAL:
7015       case NATURALN:
7016       case NEW:
7017       case NEXTVAL:
7018       case NO:
7019       case NOCOPY:
7020       case NONEDITIONABLE:
7021       case NOT:
7022       case NOWAIT:
7023       case NULL:
7024       case NULLIF:
7025       case NUMBER:
7026       case BFILE_BASE:
7027       case BLOB_BASE:
7028       case CLOB_BASE:
7029       case DATE_BASE:
7030       case NUMBER_BASE:
7031       case OBJECT:
7032       case OCIROWID:
7033       case OF:
7034       case OID:
7035       case ON:
7036       case OPAQUE:
7037       case OPEN:
7038       case OPERATOR:
7039       case OPTION:
7040       case OR:
7041       case ORDER:
7042       case ORGANIZATION:
7043       case OTHERS:
7044       case OUT:
7045       case OVERRIDING:
7046       case PACKAGE:
7047       case PARTITION:
7048       case PCTFREE:
7049       case PLS_INTEGER:
7050       case POSITIVE:
7051       case POSITIVEN:
7052       case PRESERVE:
7053       case PRIOR:
7054       case PROMPT:
7055       case PRIVATE:
7056       case PROCEDURE:
7057       case PUBLIC:
7058       case RAISE:
7059       case RANGE:
7060       case RAW:
7061       case REAL:
7062       case RECORD:
7063       case REF:
7064       case RELEASE:
7065       case RELIES_ON:
7066       case RENAME:
7067       case RESULT:
7068       case RETURN:
7069       case RETURNING:
7070       case REVERSE:
7071       case ROLLBACK:
7072       case ROW:
7073       case ROWS:
7074       case ROWID:
7075       case ROWNUM:
7076       case ROWTYPE:
7077       case SAVE:
7078       case SAVEPOINT:
7079       case SECOND:
7080       case SELECT:
7081       case SELF:
7082       case SEPARATE:
7083       case SET:
7084       case SHARE:
7085       case SMALLINT:
7086       case SPACE:
7087       case SQL:
7088       case SQLCODE:
7089       case SQLERRM:
7090       case START:
7091       case STATIC:
7092       case STDDEV:
7093       case SUBTYPE:
7094       case SUBSTITUTABLE:
7095       case SUCCESSFUL:
7096       case SUM:
7097       case SYNONYM:
7098       case SYSDATE:
7099       case SYS_REFCURSOR:
7100       case TABLE:
7101       case TEMPORARY:
7102       case THEN:
7103       case TIME:
7104       case TIMESTAMP:
7105       case TIMEZONE_REGION:
7106       case TIMEZONE_ABBR:
7107       case TIMEZONE_MINUTE:
7108       case TIMEZONE_HOUR:
7109       case TO:
7110       case TRANSACTION:
7111       case TRIGGER:
7112       case TRUE:
7113       case TYPE:
7114       case UI:
7115       case UNDER:
7116       case USING:
7117       case WHILE:
7118       case YES:
7119       case SHOW:
7120       case A:
7121       case UPDATE:
7122       case VARCHAR:
7123       case VARCHAR2:
7124       case DOUBLE:
7125       case DEC:
7126       case PRECISION:
7127       case INT:
7128       case NUMERIC:
7129       case SIGNTYPE:
7130       case NCHAR:
7131       case NVARCHAR2:
7132       case STRING:
7133       case UROWID:
7134       case VARRAY:
7135       case VARYING:
7136       case BFILE:
7137       case BLOB:
7138       case CLOB:
7139       case NCLOB:
7140       case YEAR:
7141       case LOCAL:
7142       case WITH:
7143       case ZONE:
7144       case CHARACTER:
7145       case AFTER:
7146       case BEFORE:
7147       case OLD:
7148       case PARENT:
7149       case ANALYZE:
7150       case ASSOCIATE:
7151       case AUDIT:
7152       case COMPOUND:
7153       case DATABASE:
7154       case CALL:
7155       case DDL:
7156       case DISASSOCIATE:
7157       case EACH:
7158       case FOLLOWS:
7159       case LOGOFF:
7160       case LOGON:
7161       case NESTED:
7162       case NOAUDIT:
7163       case SCHEMA:
7164       case SERVERERROR:
7165       case SHUTDOWN:
7166       case STARTUP:
7167       case STATEMENT:
7168       case STATISTICS:
7169       case SUSPEND:
7170       case TRUNCATE:
7171       case WRAPPED:
7172       case LIBRARY:
7173       case NAME:
7174       case STRUCT:
7175       case CONTEXT:
7176       case PARAMETERS:
7177       case LENGTH:
7178       case TDO:
7179       case MAXLEN:
7180       case CHARSETID:
7181       case CHARSETFORM:
7182       case ACCEPT:
7183       case ACCESSIBLE:
7184       case COPY:
7185       case DEFINE:
7186       case DISCONNECT:
7187       case HOST:
7188       case PRINT:
7189       case QUIT:
7190       case REMARK:
7191       case UNDEFINE:
7192       case VARIABLE:
7193       case WHENEVER:
7194       case ATTACH:
7195       case CAST:
7196       case TREAT:
7197       case TRIM:
7198       case LEFT:
7199       case RIGHT:
7200       case BOTH:
7201       case EMPTY:
7202       case MULTISET:
7203       case SUBMULTISET:
7204       case LEADING:
7205       case TRAILING:
7206       case CHAR_CS:
7207       case NCHAR_CS:
7208       case DBTIMEZONE:
7209       case SESSIONTIMEZONE:
7210       case AUTHENTICATED:
7211       case LINK:
7212       case SHARED:
7213       case DIRECTORY:
7214       case USER:
7215       case IDENTIFIER:
7216       case QUOTED_LITERAL:
7217       case SQLDATA_CLASS:
7218       case CUSTOMDATUM_CLASS:
7219       case ORADATA_CLASS:
7220       case JAVA_INTERFACE_CLASS:
7221         simpleNode = FormalParameter();
7222                                          sb.append(simpleNode.getImage());
7223         label_17:
7224         while (true) {
7225           switch (jj_nt.kind) {
7226           case 6:
7227             ;
7228             break;
7229           default:
7230             jj_la1[81] = jj_gen;
7231             break label_17;
7232           }
7233           jj_consume_token(6);
7234           simpleNode = FormalParameter();
7235                                                sb.append(","+simpleNode.getImage());
7236         }
7237         break;
7238       default:
7239         jj_la1[82] = jj_gen;
7240         ;
7241       }
7242       jj_consume_token(7);
7243        sb.append(")");
7244     jjtree.closeNodeScope(jjtn000, true);
7245     jjtc000 = false;
7246     jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
7247     } catch (Throwable jjte000) {
7248     if (jjtc000) {
7249       jjtree.clearNodeScope(jjtn000);
7250       jjtc000 = false;
7251     } else {
7252       jjtree.popNode();
7253     }
7254     if (jjte000 instanceof RuntimeException) {
7255       {if (true) throw (RuntimeException)jjte000;}
7256     }
7257     if (jjte000 instanceof ParseException) {
7258       {if (true) throw (ParseException)jjte000;}
7259     }
7260     {if (true) throw (Error)jjte000;}
7261     } finally {
7262     if (jjtc000) {
7263       jjtree.closeNodeScope(jjtn000, true);
7264     }
7265     }
7266     throw new Error("Missing return statement in function");
7267   }
7268 
7269   final public ASTVariableOrConstantDeclarator VariableOrConstantDeclarator() throws ParseException {
7270  /*@bgen(jjtree) VariableOrConstantDeclarator */
7271  ASTVariableOrConstantDeclarator jjtn000 = new ASTVariableOrConstantDeclarator(this, JJTVARIABLEORCONSTANTDECLARATOR);
7272  boolean jjtc000 = true;
7273  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7274  StringBuilder sb = new StringBuilder();
7275     try {
7276       simpleNode = VariableOrConstantDeclaratorId();
7277                                                   sb.append(simpleNode.getImage());
7278       if (jj_2_26(2)) {
7279         jj_consume_token(CONSTANT);
7280                             sb.append(" " + token.image);
7281       } else {
7282         ;
7283       }
7284       simpleNode = Datatype();
7285                                                                                        sb.append(" " + simpleNode.getImage());
7286       switch (jj_nt.kind) {
7287       case NOT:
7288       case NULL:
7289         switch (jj_nt.kind) {
7290         case NOT:
7291           jj_consume_token(NOT);
7292            sb.append(" " + token.image);
7293           break;
7294         default:
7295           jj_la1[83] = jj_gen;
7296           ;
7297         }
7298         jj_consume_token(NULL);
7299                                                     sb.append(" " + token.image);
7300         break;
7301       default:
7302         jj_la1[84] = jj_gen;
7303         ;
7304       }
7305       switch (jj_nt.kind) {
7306       case 9:
7307       case _DEFAULT:
7308         switch (jj_nt.kind) {
7309         case 9:
7310           jj_consume_token(9);
7311           jj_consume_token(10);
7312                sb.append(" :=");
7313           break;
7314         case _DEFAULT:
7315           jj_consume_token(_DEFAULT);
7316                                                sb.append(" " + token.image);
7317           break;
7318         default:
7319           jj_la1[85] = jj_gen;
7320           jj_consume_token(-1);
7321           throw new ParseException();
7322         }
7323         simpleNode = VariableOrConstantInitializer();
7324                                                    sb.append(" " + simpleNode.getImage());
7325         break;
7326       default:
7327         jj_la1[86] = jj_gen;
7328         ;
7329       }
7330     jjtree.closeNodeScope(jjtn000, true);
7331     jjtc000 = false;
7332     jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
7333     } catch (Throwable jjte000) {
7334     if (jjtc000) {
7335       jjtree.clearNodeScope(jjtn000);
7336       jjtc000 = false;
7337     } else {
7338       jjtree.popNode();
7339     }
7340     if (jjte000 instanceof RuntimeException) {
7341       {if (true) throw (RuntimeException)jjte000;}
7342     }
7343     if (jjte000 instanceof ParseException) {
7344       {if (true) throw (ParseException)jjte000;}
7345     }
7346     {if (true) throw (Error)jjte000;}
7347     } finally {
7348     if (jjtc000) {
7349       jjtree.closeNodeScope(jjtn000, true);
7350     }
7351     }
7352     throw new Error("Missing return statement in function");
7353   }
7354 
7355   final public ASTVariableOrConstantDeclaratorId VariableOrConstantDeclaratorId() throws ParseException {
7356  /*@bgen(jjtree) VariableOrConstantDeclaratorId */
7357  ASTVariableOrConstantDeclaratorId jjtn000 = new ASTVariableOrConstantDeclaratorId(this, JJTVARIABLEORCONSTANTDECLARATORID);
7358  boolean jjtc000 = true;
7359  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7360     try {
7361       simpleNode = ID();
7362     jjtree.closeNodeScope(jjtn000, true);
7363     jjtc000 = false;
7364     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
7365     } catch (Throwable jjte000) {
7366     if (jjtc000) {
7367       jjtree.clearNodeScope(jjtn000);
7368       jjtc000 = false;
7369     } else {
7370       jjtree.popNode();
7371     }
7372     if (jjte000 instanceof RuntimeException) {
7373       {if (true) throw (RuntimeException)jjte000;}
7374     }
7375     if (jjte000 instanceof ParseException) {
7376       {if (true) throw (ParseException)jjte000;}
7377     }
7378     {if (true) throw (Error)jjte000;}
7379     } finally {
7380     if (jjtc000) {
7381       jjtree.closeNodeScope(jjtn000, true);
7382     }
7383     }
7384     throw new Error("Missing return statement in function");
7385   }
7386 
7387   final public ASTVariableOrConstantInitializer VariableOrConstantInitializer() throws ParseException {
7388  /*@bgen(jjtree) VariableOrConstantInitializer */
7389  ASTVariableOrConstantInitializer jjtn000 = new ASTVariableOrConstantInitializer(this, JJTVARIABLEORCONSTANTINITIALIZER);
7390  boolean jjtc000 = true;
7391  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7392     try {
7393       simpleNode = Expression();
7394     jjtree.closeNodeScope(jjtn000, true);
7395     jjtc000 = false;
7396     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
7397     } catch (Throwable jjte000) {
7398    if (jjtc000) {
7399      jjtree.clearNodeScope(jjtn000);
7400      jjtc000 = false;
7401    } else {
7402      jjtree.popNode();
7403    }
7404    if (jjte000 instanceof RuntimeException) {
7405      {if (true) throw (RuntimeException)jjte000;}
7406    }
7407    if (jjte000 instanceof ParseException) {
7408      {if (true) throw (ParseException)jjte000;}
7409    }
7410    {if (true) throw (Error)jjte000;}
7411     } finally {
7412    if (jjtc000) {
7413      jjtree.closeNodeScope(jjtn000, true);
7414    }
7415     }
7416     throw new Error("Missing return statement in function");
7417   }
7418 
7419   final public ASTDatatype Datatype() throws ParseException {
7420  /*@bgen(jjtree) Datatype */
7421  ASTDatatype jjtn000 = new ASTDatatype(this, JJTDATATYPE);
7422  boolean jjtc000 = true;
7423  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7424  StringBuilder sb = new StringBuilder();
7425     try {
7426       switch (jj_nt.kind) {
7427       case CC_IF:
7428         // this should be first
7429                         simpleNode = CompilationDataType();
7430                                                     sb.append(simpleNode.getImage());
7431         break;
7432       default:
7433         jj_la1[90] = jj_gen;
7434         if (jj_2_28(2)) {
7435           simpleNode = ScalarDataTypeName();
7436                                                                 sb.append(simpleNode.getImage());
7437         } else {
7438           switch (jj_nt.kind) {
7439           case REPLACE:
7440           case DEFINER:
7441           case CURRENT_USER:
7442           case LANGUAGE:
7443           case INLINE:
7444           case ADD:
7445           case AGGREGATE:
7446           case ARRAY:
7447           case AT:
7448           case ATTRIBUTE:
7449           case AUTHID:
7450           case BODY:
7451           case BULK:
7452           case BYTE:
7453           case CASCADE:
7454           case CLOSE:
7455           case COALESCE:
7456           case COLLECT:
7457           case COLUMN:
7458           case COMMENT:
7459           case COMMIT:
7460           case CONSTRUCTOR:
7461           case CONTINUE:
7462           case CONVERT:
7463           case CURRENT:
7464           case CURSOR:
7465           case DATA:
7466           case DAY:
7467           case DISABLE:
7468           case EDITIONABLE:
7469           case ELEMENT:
7470           case ENABLE:
7471           case ESCAPE:
7472           case EXCEPT:
7473           case EXCEPTIONS:
7474           case EXIT:
7475           case EXTERNAL:
7476           case EXTENDS:
7477           case EXTRACT:
7478           case FALSE:
7479           case FINAL:
7480           case FORCE:
7481           case FUNCTION:
7482           case GLOBAL:
7483           case HASH:
7484           case HEAP:
7485           case HOUR:
7486           case IMMEDIATE:
7487           case INDICES:
7488           case INDEXTYPE:
7489           case INDICATOR:
7490           case INSTANTIABLE:
7491           case INTERVAL:
7492           case INVALIDATE:
7493           case ISOLATION:
7494           case JAVA:
7495           case LEVEL:
7496           case LIMIT:
7497           case LOOP:
7498           case MAP:
7499           case MAX:
7500           case MEMBER:
7501           case MERGE:
7502           case MIN:
7503           case MINUTE:
7504           case MLSLABEL:
7505           case MODIFY:
7506           case MOD:
7507           case MONTH:
7508           case NATURAL:
7509           case NEW:
7510           case NO:
7511           case NONEDITIONABLE:
7512           case NULLIF:
7513           case OBJECT:
7514           case OID:
7515           case OPAQUE:
7516           case OPEN:
7517           case OPERATOR:
7518           case ORGANIZATION:
7519           case OTHERS:
7520           case OVERRIDING:
7521           case PACKAGE:
7522           case PARTITION:
7523           case PRESERVE:
7524           case PRIVATE:
7525           case PROCEDURE:
7526           case RANGE:
7527           case RAW:
7528           case REAL:
7529           case RECORD:
7530           case REF:
7531           case RELEASE:
7532           case RELIES_ON:
7533           case RENAME:
7534           case RESULT:
7535           case RETURN:
7536           case RETURNING:
7537           case REVERSE:
7538           case ROLLBACK:
7539           case ROW:
7540           case ROWS:
7541           case ROWID:
7542           case ROWNUM:
7543           case SAVE:
7544           case SAVEPOINT:
7545           case SECOND:
7546           case SELF:
7547           case SET:
7548           case SPACE:
7549           case SQL:
7550           case SQLCODE:
7551           case SQLERRM:
7552           case STATIC:
7553           case SUBTYPE:
7554           case SUBSTITUTABLE:
7555           case SUCCESSFUL:
7556           case SYSDATE:
7557           case SYS_REFCURSOR:
7558           case TEMPORARY:
7559           case TIME:
7560           case TIMESTAMP:
7561           case TIMEZONE_REGION:
7562           case TIMEZONE_ABBR:
7563           case TIMEZONE_MINUTE:
7564           case TIMEZONE_HOUR:
7565           case TRANSACTION:
7566           case TRUE:
7567           case TYPE:
7568           case UNDER:
7569           case USING:
7570           case YES:
7571           case SHOW:
7572           case A:
7573           case DOUBLE:
7574           case DEC:
7575           case PRECISION:
7576           case INT:
7577           case NUMERIC:
7578           case NCHAR:
7579           case NVARCHAR2:
7580           case STRING:
7581           case UROWID:
7582           case VARRAY:
7583           case VARYING:
7584           case BFILE:
7585           case BLOB:
7586           case CLOB:
7587           case NCLOB:
7588           case YEAR:
7589           case LOCAL:
7590           case ZONE:
7591           case CHARACTER:
7592           case AFTER:
7593           case BEFORE:
7594           case OLD:
7595           case PARENT:
7596           case ANALYZE:
7597           case ASSOCIATE:
7598           case AUDIT:
7599           case COMPOUND:
7600           case DATABASE:
7601           case CALL:
7602           case DDL:
7603           case DISASSOCIATE:
7604           case EACH:
7605           case FOLLOWS:
7606           case LOGOFF:
7607           case LOGON:
7608           case NESTED:
7609           case NOAUDIT:
7610           case SCHEMA:
7611           case SERVERERROR:
7612           case SHUTDOWN:
7613           case STARTUP:
7614           case STATEMENT:
7615           case STATISTICS:
7616           case SUSPEND:
7617           case TRUNCATE:
7618           case WRAPPED:
7619           case LIBRARY:
7620           case NAME:
7621           case STRUCT:
7622           case CONTEXT:
7623           case PARAMETERS:
7624           case LENGTH:
7625           case TDO:
7626           case MAXLEN:
7627           case CHARSETID:
7628           case CHARSETFORM:
7629           case ACCEPT:
7630           case ACCESSIBLE:
7631           case COPY:
7632           case DEFINE:
7633           case DISCONNECT:
7634           case HOST:
7635           case PRINT:
7636           case QUIT:
7637           case REMARK:
7638           case UNDEFINE:
7639           case VARIABLE:
7640           case WHENEVER:
7641           case ATTACH:
7642           case CAST:
7643           case TREAT:
7644           case TRIM:
7645           case LEFT:
7646           case RIGHT:
7647           case BOTH:
7648           case EMPTY:
7649           case MULTISET:
7650           case SUBMULTISET:
7651           case LEADING:
7652           case TRAILING:
7653           case CHAR_CS:
7654           case NCHAR_CS:
7655           case DBTIMEZONE:
7656           case SESSIONTIMEZONE:
7657           case AUTHENTICATED:
7658           case LINK:
7659           case SHARED:
7660           case DIRECTORY:
7661           case USER:
7662           case IDENTIFIER:
7663           case QUOTED_LITERAL:
7664             if (jj_2_27(2)) {
7665               jj_consume_token(REF);
7666                                           sb.append(token.image);
7667             } else {
7668               ;
7669             }
7670             simpleNode = QualifiedName();
7671                                                                                                     sb.append(simpleNode.getImage());
7672             switch (jj_nt.kind) {
7673             case 2:
7674               jj_consume_token(2);
7675               simpleNode = QualifiedName();
7676                                                        sb.append("@"+simpleNode.getImage());
7677               break;
7678             default:
7679               jj_la1[87] = jj_gen;
7680               ;
7681             }
7682             switch (jj_nt.kind) {
7683             case 11:
7684               jj_consume_token(11);
7685               switch (jj_nt.kind) {
7686               case TYPE:
7687                 jj_consume_token(TYPE);
7688                 break;
7689               case ROWTYPE:
7690                 jj_consume_token(ROWTYPE);
7691                 break;
7692               default:
7693                 jj_la1[88] = jj_gen;
7694                 jj_consume_token(-1);
7695                 throw new ParseException();
7696               }
7697                                             sb.append("%"+token.image);
7698               break;
7699             default:
7700               jj_la1[89] = jj_gen;
7701               ;
7702             }
7703             break;
7704           default:
7705             jj_la1[91] = jj_gen;
7706             jj_consume_token(-1);
7707             throw new ParseException();
7708           }
7709         }
7710       }
7711           jjtree.closeNodeScope(jjtn000, true);
7712           jjtc000 = false;
7713           jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
7714     } catch (Throwable jjte000) {
7715           if (jjtc000) {
7716             jjtree.clearNodeScope(jjtn000);
7717             jjtc000 = false;
7718           } else {
7719             jjtree.popNode();
7720           }
7721           if (jjte000 instanceof RuntimeException) {
7722             {if (true) throw (RuntimeException)jjte000;}
7723           }
7724           if (jjte000 instanceof ParseException) {
7725             {if (true) throw (ParseException)jjte000;}
7726           }
7727           {if (true) throw (Error)jjte000;}
7728     } finally {
7729           if (jjtc000) {
7730             jjtree.closeNodeScope(jjtn000, true);
7731           }
7732     }
7733     throw new Error("Missing return statement in function");
7734   }
7735 
7736   final public ASTCompilationDataType CompilationDataType() throws ParseException {
7737  /*@bgen(jjtree) CompilationDataType */
7738   ASTCompilationDataType jjtn000 = new ASTCompilationDataType(this, JJTCOMPILATIONDATATYPE);
7739   boolean jjtc000 = true;
7740   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
7741   StringBuilder sb = new StringBuilder() ;
7742     try {
7743       jj_consume_token(CC_IF);
7744                    sb.append(" "); sb.append(token.image) ;
7745       simpleNode = ConditionalOrExpression();
7746                                                  sb.append(" "); sb.append(simpleNode.getImage());
7747       jj_consume_token(CC_THEN);
7748                      sb.append(" "); sb.append(token.image);
7749       simpleNode = Datatype();
7750                                    sb.append(" "); sb.append(simpleNode.getImage());
7751       label_18:
7752       while (true) {
7753         switch (jj_nt.kind) {
7754         case CC_ELSIF:
7755           ;
7756           break;
7757         default:
7758           jj_la1[92] = jj_gen;
7759           break label_18;
7760         }
7761         jj_consume_token(CC_ELSIF);
7762                         sb.append(" "); sb.append(token.image);
7763         simpleNode = ConditionalOrExpression();
7764                                                     sb.append(" "); sb.append(simpleNode.getImage());
7765         jj_consume_token(CC_THEN);
7766                        sb.append(" "); sb.append(token.image);
7767         simpleNode = Datatype();
7768                                      sb.append(" "); sb.append(simpleNode.getImage());
7769       }
7770       label_19:
7771       while (true) {
7772         switch (jj_nt.kind) {
7773         case CC_ELSE:
7774           ;
7775           break;
7776         default:
7777           jj_la1[93] = jj_gen;
7778           break label_19;
7779         }
7780         jj_consume_token(CC_ELSE);
7781                        sb.append(" "); sb.append(token.image);
7782         simpleNode = Datatype();
7783                                       sb.append(" "); sb.append(simpleNode.getImage());
7784       }
7785       jj_consume_token(CC_END);
7786                     sb.append(" "); sb.append(token.image);
7787    jjtree.closeNodeScope(jjtn000, true);
7788    jjtc000 = false;
7789  jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
7790     } catch (Throwable jjte000) {
7791           if (jjtc000) {
7792             jjtree.clearNodeScope(jjtn000);
7793             jjtc000 = false;
7794           } else {
7795             jjtree.popNode();
7796           }
7797           if (jjte000 instanceof RuntimeException) {
7798             {if (true) throw (RuntimeException)jjte000;}
7799           }
7800           if (jjte000 instanceof ParseException) {
7801             {if (true) throw (ParseException)jjte000;}
7802           }
7803           {if (true) throw (Error)jjte000;}
7804     } finally {
7805           if (jjtc000) {
7806             jjtree.closeNodeScope(jjtn000, true);
7807           }
7808     }
7809     throw new Error("Missing return statement in function");
7810   }
7811 
7812   final public ASTCollectionTypeName CollectionTypeName() throws ParseException {
7813  /*@bgen(jjtree) CollectionTypeName */
7814   ASTCollectionTypeName jjtn000 = new ASTCollectionTypeName(this, JJTCOLLECTIONTYPENAME);
7815   boolean jjtc000 = true;
7816   jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null;
7817         StringBuilder sb = new StringBuilder();
7818     try {
7819       switch (jj_nt.kind) {
7820       case TABLE:
7821         jj_consume_token(TABLE);
7822         break;
7823       case VARRAY:
7824         jj_consume_token(VARRAY);
7825         break;
7826       case VARYING:
7827         jj_consume_token(VARYING);
7828         jj_consume_token(ARRAY);
7829                                                 sb.append( "VARYING ARRAY") ;
7830         break;
7831       default:
7832         jj_la1[94] = jj_gen;
7833         jj_consume_token(-1);
7834         throw new ParseException();
7835       }
7836       if (sb.length() ==  0) {
7837         sb.append(token.toString());
7838       }
7839       if (jj_2_29(2)) {
7840         jj_consume_token(5);
7841         size = NumericLiteral();
7842                                                  sb.append( "(" + size);
7843         switch (jj_nt.kind) {
7844         case 6:
7845           jj_consume_token(6);
7846           precision = NumericLiteral();
7847                                                  sb.append( "," + precision);
7848           break;
7849         default:
7850           jj_la1[95] = jj_gen;
7851           ;
7852         }
7853         switch (jj_nt.kind) {
7854         case CHAR:
7855           jj_consume_token(CHAR);
7856                           sb.append( " CHAR") ;
7857           break;
7858         default:
7859           jj_la1[96] = jj_gen;
7860           ;
7861         }
7862         switch (jj_nt.kind) {
7863         case BYTE:
7864           jj_consume_token(BYTE);
7865                           sb.append( " BYTE") ;
7866           break;
7867         default:
7868           jj_la1[97] = jj_gen;
7869           ;
7870         }
7871         jj_consume_token(7);
7872              sb.append( ")");
7873       } else {
7874         ;
7875       }
7876         jjtree.closeNodeScope(jjtn000, true);
7877         jjtc000 = false;
7878         jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
7879     } catch (Throwable jjte000) {
7880        if (jjtc000) {
7881          jjtree.clearNodeScope(jjtn000);
7882          jjtc000 = false;
7883        } else {
7884          jjtree.popNode();
7885        }
7886        if (jjte000 instanceof RuntimeException) {
7887          {if (true) throw (RuntimeException)jjte000;}
7888        }
7889        if (jjte000 instanceof ParseException) {
7890          {if (true) throw (ParseException)jjte000;}
7891        }
7892        {if (true) throw (Error)jjte000;}
7893     } finally {
7894        if (jjtc000) {
7895          jjtree.closeNodeScope(jjtn000, true);
7896        }
7897     }
7898     throw new Error("Missing return statement in function");
7899   }
7900 
7901   final public ASTScalarDataTypeName ScalarDataTypeName() throws ParseException {
7902  /*@bgen(jjtree) ScalarDataTypeName */
7903   ASTScalarDataTypeName jjtn000 = new ASTScalarDataTypeName(this, JJTSCALARDATATYPENAME);
7904   boolean jjtc000 = true;
7905   jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null ;
7906         StringBuilder name = new StringBuilder();
7907         PLSQLNode characterSet = null;
7908     try {
7909       switch (jj_nt.kind) {
7910       case BFILE_BASE:
7911         jj_consume_token(BFILE_BASE);
7912         break;
7913       case BLOB_BASE:
7914         jj_consume_token(BLOB_BASE);
7915         break;
7916       case CHAR_BASE:
7917         jj_consume_token(CHAR_BASE);
7918         break;
7919       case CLOB_BASE:
7920         jj_consume_token(CLOB_BASE);
7921         break;
7922       case DATE_BASE:
7923         jj_consume_token(DATE_BASE);
7924         break;
7925       case NUMBER_BASE:
7926         jj_consume_token(NUMBER_BASE);
7927         break;
7928       case BINARY_INTEGER:
7929         jj_consume_token(BINARY_INTEGER);
7930         break;
7931       case DEC:
7932         jj_consume_token(DEC);
7933         break;
7934       case DECIMAL:
7935         jj_consume_token(DECIMAL);
7936         break;
7937       case DOUBLE:
7938         jj_consume_token(DOUBLE);
7939         jj_consume_token(PRECISION);
7940                                                                      name.append("DOUBLE PRECISION");
7941         break;
7942       case FLOAT:
7943         jj_consume_token(FLOAT);
7944         break;
7945       case INT:
7946         jj_consume_token(INT);
7947         break;
7948       case INTEGER:
7949         jj_consume_token(INTEGER);
7950         break;
7951       case NATURAL:
7952         jj_consume_token(NATURAL);
7953         break;
7954       case NATURALN:
7955         jj_consume_token(NATURALN);
7956         break;
7957       case NUMBER:
7958         jj_consume_token(NUMBER);
7959         break;
7960       case NUMERIC:
7961         jj_consume_token(NUMERIC);
7962         break;
7963       case PLS_INTEGER:
7964         jj_consume_token(PLS_INTEGER);
7965         break;
7966       case POSITIVE:
7967         jj_consume_token(POSITIVE);
7968         break;
7969       case POSITIVEN:
7970         jj_consume_token(POSITIVEN);
7971         break;
7972       case REAL:
7973         jj_consume_token(REAL);
7974         break;
7975       case SIGNTYPE:
7976         jj_consume_token(SIGNTYPE);
7977         break;
7978       case SMALLINT:
7979         jj_consume_token(SMALLINT);
7980         break;
7981       case CHAR:
7982       case LONG:
7983       case RAW:
7984       case ROWID:
7985       case VARCHAR:
7986       case VARCHAR2:
7987       case NCHAR:
7988       case NVARCHAR2:
7989       case STRING:
7990       case UROWID:
7991       case CLOB:
7992       case NCLOB:
7993       case CHARACTER:
7994         switch (jj_nt.kind) {
7995         case CHAR:
7996           jj_consume_token(CHAR);
7997           break;
7998         case CHARACTER:
7999           jj_consume_token(CHARACTER);
8000           break;
8001         default:
8002           jj_la1[98] = jj_gen;
8003           if (jj_2_30(2)) {
8004             jj_consume_token(LONG);
8005             jj_consume_token(RAW);
8006                                        name.append("LONG RAW");
8007           } else {
8008             switch (jj_nt.kind) {
8009             case LONG:
8010               jj_consume_token(LONG);
8011               break;
8012             case NCHAR:
8013               jj_consume_token(NCHAR);
8014               break;
8015             case NVARCHAR2:
8016               jj_consume_token(NVARCHAR2);
8017               break;
8018             case RAW:
8019               jj_consume_token(RAW);
8020               break;
8021             case ROWID:
8022               jj_consume_token(ROWID);
8023               break;
8024             case STRING:
8025               jj_consume_token(STRING);
8026               break;
8027             case UROWID:
8028               jj_consume_token(UROWID);
8029               break;
8030             case VARCHAR:
8031               jj_consume_token(VARCHAR);
8032               break;
8033             case VARCHAR2:
8034               jj_consume_token(VARCHAR2);
8035               break;
8036             case CLOB:
8037               jj_consume_token(CLOB);
8038               break;
8039             case NCLOB:
8040               jj_consume_token(NCLOB);
8041               break;
8042             default:
8043               jj_la1[99] = jj_gen;
8044               jj_consume_token(-1);
8045               throw new ParseException();
8046             }
8047           }
8048         }
8049         break;
8050       case BOOLEAN:
8051         jj_consume_token(BOOLEAN);
8052         break;
8053       case BFILE:
8054         jj_consume_token(BFILE);
8055         break;
8056       case BLOB:
8057         jj_consume_token(BLOB);
8058         break;
8059       case SYS_REFCURSOR:
8060         jj_consume_token(SYS_REFCURSOR);
8061         break;
8062       case REF:
8063         jj_consume_token(REF);
8064         jj_consume_token(CURSOR);
8065                         name.append("REF CURSOR");
8066         break;
8067       case DATE:
8068         jj_consume_token(DATE);
8069         break;
8070       default:
8071         jj_la1[100] = jj_gen;
8072         if (jj_2_31(2)) {
8073           jj_consume_token(INTERVAL);
8074           jj_consume_token(YEAR);
8075                                         name.append("INTERVAL YEAR");
8076         } else if (jj_2_32(2)) {
8077           jj_consume_token(INTERVAL);
8078           jj_consume_token(DAY);
8079                                        name.append("INTERVAL DAY");
8080         } else {
8081           switch (jj_nt.kind) {
8082           case TIME:
8083             jj_consume_token(TIME);
8084             break;
8085           case TIMESTAMP:
8086             jj_consume_token(TIMESTAMP);
8087             break;
8088           case SELF:
8089             jj_consume_token(SELF);
8090             jj_consume_token(AS);
8091             jj_consume_token(RESULT);
8092                              name.append("SELF AS RESULT");
8093             break;
8094           default:
8095             jj_la1[101] = jj_gen;
8096             jj_consume_token(-1);
8097             throw new ParseException();
8098           }
8099         }
8100       }
8101       if (name.length() == 0 ) {
8102         name.append(token.toString());
8103       }
8104       if (jj_2_33(2)) {
8105         jj_consume_token(5);
8106         size = NumericLiteral();
8107                                                  name.append("("); name.append(size.getImage()) ;
8108         switch (jj_nt.kind) {
8109         case 6:
8110           jj_consume_token(6);
8111           precision = UnaryExpression(true);
8112                                                       name.append(",") ; name.append(precision.getImage()) ;
8113           break;
8114         default:
8115           jj_la1[102] = jj_gen;
8116           ;
8117         }
8118         switch (jj_nt.kind) {
8119         case CHAR:
8120           jj_consume_token(CHAR);
8121                           name.append(" CHAR") ;
8122           break;
8123         default:
8124           jj_la1[103] = jj_gen;
8125           ;
8126         }
8127         switch (jj_nt.kind) {
8128         case BYTE:
8129           jj_consume_token(BYTE);
8130                           name.append(" BYTE") ;
8131           break;
8132         default:
8133           jj_la1[104] = jj_gen;
8134           ;
8135         }
8136         jj_consume_token(7);
8137              name.append( ")") ;
8138       } else {
8139         ;
8140       }
8141       switch (jj_nt.kind) {
8142       case TO:
8143       case WITH:
8144       case CHARACTER:
8145         switch (jj_nt.kind) {
8146         case CHARACTER:
8147           jj_consume_token(CHARACTER);
8148           jj_consume_token(SET);
8149           characterSet = Name();
8150                                               name.append( " CHARACTER SET ") ;  name.append(characterSet.getImage()) ;
8151           break;
8152         default:
8153           jj_la1[105] = jj_gen;
8154           if (jj_2_35(4)) {
8155             jj_consume_token(WITH);
8156             jj_consume_token(LOCAL);
8157             jj_consume_token(TIME);
8158             jj_consume_token(ZONE);
8159                                              name.append(" WITH LOCAL TIME ZONE");
8160           } else if (jj_2_36(3)) {
8161             jj_consume_token(WITH);
8162             jj_consume_token(TIME);
8163             jj_consume_token(ZONE);
8164                                       name.append( " WITH TIME ZONE");
8165           } else if (jj_2_37(2)) {
8166             jj_consume_token(TO);
8167             jj_consume_token(MONTH);
8168                                name.append( " TO MONTH");
8169           } else if (jj_2_38(2)) {
8170             jj_consume_token(TO);
8171             jj_consume_token(SECOND);
8172                                 name.append( " TO SECOND");
8173             if (jj_2_34(2)) {
8174               jj_consume_token(5);
8175               precision = NumericLiteral();
8176                                                                        name.append( "(" + precision) ;
8177               jj_consume_token(7);
8178                                              name.append( ")");
8179             } else {
8180               ;
8181             }
8182           } else {
8183             jj_consume_token(-1);
8184             throw new ParseException();
8185           }
8186         }
8187         break;
8188       default:
8189         jj_la1[106] = jj_gen;
8190         ;
8191       }
8192         jjtree.closeNodeScope(jjtn000, true);
8193         jjtc000 = false;
8194         jjtn000.setImage(name.toString()) ;  {if (true) return jjtn000;}
8195     } catch (Throwable jjte000) {
8196           if (jjtc000) {
8197             jjtree.clearNodeScope(jjtn000);
8198             jjtc000 = false;
8199           } else {
8200             jjtree.popNode();
8201           }
8202           if (jjte000 instanceof RuntimeException) {
8203             {if (true) throw (RuntimeException)jjte000;}
8204           }
8205           if (jjte000 instanceof ParseException) {
8206             {if (true) throw (ParseException)jjte000;}
8207           }
8208           {if (true) throw (Error)jjte000;}
8209     } finally {
8210           if (jjtc000) {
8211             jjtree.closeNodeScope(jjtn000, true);
8212           }
8213     }
8214     throw new Error("Missing return statement in function");
8215   }
8216 
8217   final public ASTDateTimeLiteral DateTimeLiteral() throws ParseException {
8218  /*@bgen(jjtree) DateTimeLiteral */
8219  ASTDateTimeLiteral jjtn000 = new ASTDateTimeLiteral(this, JJTDATETIMELITERAL);
8220  boolean jjtc000 = true;
8221  jjtree.openNodeScope(jjtn000);Token t = null ;
8222  PLSQLNode simpleNode = null ;
8223  StringBuilder sb = new StringBuilder() ;
8224     try {
8225       switch (jj_nt.kind) {
8226       case INTERVAL:
8227         jj_consume_token(INTERVAL);
8228         break;
8229       case TIMESTAMP:
8230         jj_consume_token(TIMESTAMP);
8231         break;
8232       case DATE:
8233         jj_consume_token(DATE);
8234         break;
8235       default:
8236         jj_la1[107] = jj_gen;
8237         jj_consume_token(-1);
8238         throw new ParseException();
8239       }
8240           sb.append(token.image);
8241       switch (jj_nt.kind) {
8242       case CHARACTER_LITERAL:
8243         jj_consume_token(CHARACTER_LITERAL);
8244                                 sb.append(" ");  sb.append(token.image);
8245         break;
8246       case STRING_LITERAL:
8247         simpleNode = StringLiteral();
8248                                         sb.append(" ");  sb.append(simpleNode.getImage());
8249         break;
8250       default:
8251         jj_la1[108] = jj_gen;
8252         jj_consume_token(-1);
8253         throw new ParseException();
8254       }
8255       switch (jj_nt.kind) {
8256       case DAY:
8257       case HOUR:
8258       case MINUTE:
8259       case MONTH:
8260       case SECOND:
8261       case YEAR:
8262         switch (jj_nt.kind) {
8263         case YEAR:
8264           jj_consume_token(YEAR);
8265           break;
8266         case MONTH:
8267           jj_consume_token(MONTH);
8268           break;
8269         case DAY:
8270           jj_consume_token(DAY);
8271           break;
8272         case HOUR:
8273           jj_consume_token(HOUR);
8274           break;
8275         case MINUTE:
8276           jj_consume_token(MINUTE);
8277           break;
8278         case SECOND:
8279           jj_consume_token(SECOND);
8280           break;
8281         default:
8282           jj_la1[109] = jj_gen;
8283           jj_consume_token(-1);
8284           throw new ParseException();
8285         }
8286         break;
8287       default:
8288         jj_la1[110] = jj_gen;
8289         ;
8290       }
8291            if (null != t)
8292            {
8293             sb.append(" ");  sb.append(token.image);
8294             t = null;
8295            }
8296       if (jj_2_39(2)) {
8297         jj_consume_token(5);
8298         simpleNode = NumericLiteral();
8299                                                            sb.append("(");  sb.append(simpleNode.getImage());
8300         jj_consume_token(7);
8301                sb.append("}");
8302       } else {
8303         ;
8304       }
8305       switch (jj_nt.kind) {
8306       case TO:
8307       case WITH:
8308         switch (jj_nt.kind) {
8309         case WITH:
8310           jj_consume_token(WITH);
8311               sb.append(" "); sb.append(token.toString()) ;
8312           switch (jj_nt.kind) {
8313           case LOCAL:
8314             jj_consume_token(LOCAL);
8315                   sb.append(" "); sb.append(token.toString()) ;
8316             break;
8317           default:
8318             jj_la1[111] = jj_gen;
8319             ;
8320           }
8321           jj_consume_token(TIME);
8322           jj_consume_token(ZONE);
8323                     sb.append(" "); sb.append("TIME ZONE") ;
8324           break;
8325         case TO:
8326           jj_consume_token(TO);
8327             sb.append(" "); sb.append(token.toString()) ;
8328           switch (jj_nt.kind) {
8329           case YEAR:
8330             jj_consume_token(YEAR);
8331             break;
8332           case MONTH:
8333             jj_consume_token(MONTH);
8334             break;
8335           case DAY:
8336             jj_consume_token(DAY);
8337             break;
8338           case HOUR:
8339             jj_consume_token(HOUR);
8340             break;
8341           case MINUTE:
8342             jj_consume_token(MINUTE);
8343             break;
8344           case SECOND:
8345             jj_consume_token(SECOND);
8346             break;
8347           default:
8348             jj_la1[112] = jj_gen;
8349             jj_consume_token(-1);
8350             throw new ParseException();
8351           }
8352           sb.append(token.image);
8353           if (jj_2_40(2)) {
8354             jj_consume_token(5);
8355             simpleNode = NumericLiteral();
8356                                                            sb.append("(");  sb.append(simpleNode.getImage());
8357             jj_consume_token(7);
8358                 sb.append("}");
8359           } else {
8360             ;
8361           }
8362           break;
8363         default:
8364           jj_la1[113] = jj_gen;
8365           jj_consume_token(-1);
8366           throw new ParseException();
8367         }
8368         break;
8369       default:
8370         jj_la1[114] = jj_gen;
8371         ;
8372       }
8373      jjtree.closeNodeScope(jjtn000, true);
8374      jjtc000 = false;
8375     jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
8376     } catch (Throwable jjte000) {
8377       if (jjtc000) {
8378         jjtree.clearNodeScope(jjtn000);
8379         jjtc000 = false;
8380       } else {
8381         jjtree.popNode();
8382       }
8383       if (jjte000 instanceof RuntimeException) {
8384         {if (true) throw (RuntimeException)jjte000;}
8385       }
8386       if (jjte000 instanceof ParseException) {
8387         {if (true) throw (ParseException)jjte000;}
8388       }
8389       {if (true) throw (Error)jjte000;}
8390     } finally {
8391       if (jjtc000) {
8392         jjtree.closeNodeScope(jjtn000, true);
8393       }
8394     }
8395     throw new Error("Missing return statement in function");
8396   }
8397 
8398   final public ASTExceptionHandler ExceptionHandler() throws ParseException {
8399  /*@bgen(jjtree) ExceptionHandler */
8400   ASTExceptionHandler jjtn000 = new ASTExceptionHandler(this, JJTEXCEPTIONHANDLER);
8401   boolean jjtc000 = true;
8402   jjtree.openNodeScope(jjtn000);
8403     try {
8404       jj_consume_token(EXCEPTION);
8405       label_20:
8406       while (true) {
8407         if (jj_2_41(2)) {
8408           ;
8409         } else {
8410           break label_20;
8411         }
8412         jj_consume_token(WHEN);
8413         QualifiedName();
8414         label_21:
8415         while (true) {
8416           switch (jj_nt.kind) {
8417           case OR:
8418             ;
8419             break;
8420           default:
8421             jj_la1[115] = jj_gen;
8422             break label_21;
8423           }
8424           jj_consume_token(OR);
8425           QualifiedName();
8426         }
8427         jj_consume_token(THEN);
8428         label_22:
8429         while (true) {
8430           Statement();
8431           switch (jj_nt.kind) {
8432           case 5:
8433           case 16:
8434           case 17:
8435           case 21:
8436           case REPLACE:
8437           case DEFINER:
8438           case CURRENT_USER:
8439           case LANGUAGE:
8440           case INLINE:
8441           case ADD:
8442           case AGGREGATE:
8443           case ARRAY:
8444           case AT:
8445           case ATTRIBUTE:
8446           case AUTHID:
8447           case BEGIN:
8448           case BODY:
8449           case BULK:
8450           case BYTE:
8451           case CASCADE:
8452           case CASE:
8453           case CLOSE:
8454           case COALESCE:
8455           case COLLECT:
8456           case COLUMN:
8457           case COMMENT:
8458           case COMMIT:
8459           case CONSTRUCTOR:
8460           case CONTINUE:
8461           case CONVERT:
8462           case CURRENT:
8463           case CURSOR:
8464           case DATA:
8465           case DATE:
8466           case DAY:
8467           case DECLARE:
8468           case DELETE:
8469           case DISABLE:
8470           case EDITIONABLE:
8471           case ELEMENT:
8472           case ENABLE:
8473           case ESCAPE:
8474           case EXCEPT:
8475           case EXCEPTIONS:
8476           case EXECUTE:
8477           case EXIT:
8478           case EXTERNAL:
8479           case EXTENDS:
8480           case EXTRACT:
8481           case FALSE:
8482           case FETCH:
8483           case FINAL:
8484           case FOR:
8485           case FORALL:
8486           case FORCE:
8487           case FUNCTION:
8488           case GLOBAL:
8489           case GOTO:
8490           case HASH:
8491           case HEAP:
8492           case HOUR:
8493           case IF:
8494           case IMMEDIATE:
8495           case INDICES:
8496           case INDEXTYPE:
8497           case INDICATOR:
8498           case INSERT:
8499           case INSTANTIABLE:
8500           case INTERVAL:
8501           case INVALIDATE:
8502           case ISOLATION:
8503           case JAVA:
8504           case LEVEL:
8505           case LIMIT:
8506           case LOCK:
8507           case LOOP:
8508           case MAP:
8509           case MAX:
8510           case MEMBER:
8511           case MERGE:
8512           case MIN:
8513           case MINUTE:
8514           case MLSLABEL:
8515           case MODIFY:
8516           case MOD:
8517           case MONTH:
8518           case NATURAL:
8519           case NEW:
8520           case NEW_DOT:
8521           case NO:
8522           case NONEDITIONABLE:
8523           case NOT:
8524           case NULL:
8525           case NULLIF:
8526           case OBJECT:
8527           case OID:
8528           case OPAQUE:
8529           case OPEN:
8530           case OPERATOR:
8531           case ORGANIZATION:
8532           case OTHERS:
8533           case OVERRIDING:
8534           case PACKAGE:
8535           case PARTITION:
8536           case PIPE:
8537           case PRAGMA:
8538           case PRESERVE:
8539           case PRIVATE:
8540           case PROCEDURE:
8541           case RAISE:
8542           case RANGE:
8543           case RAW:
8544           case REAL:
8545           case RECORD:
8546           case REF:
8547           case RELEASE:
8548           case RELIES_ON:
8549           case RENAME:
8550           case RESULT:
8551           case RETURN:
8552           case RETURNING:
8553           case REVERSE:
8554           case ROLLBACK:
8555           case ROW:
8556           case ROWS:
8557           case ROWID:
8558           case ROWNUM:
8559           case SAVE:
8560           case SAVEPOINT:
8561           case SECOND:
8562           case SELECT:
8563           case SELF:
8564           case SET:
8565           case SPACE:
8566           case SQL:
8567           case SQLCODE:
8568           case SQLERRM:
8569           case STATIC:
8570           case SUBTYPE:
8571           case SUBSTITUTABLE:
8572           case SUCCESSFUL:
8573           case SYSDATE:
8574           case SYS_REFCURSOR:
8575           case TEMPORARY:
8576           case TIME:
8577           case TIMESTAMP:
8578           case TIMEZONE_REGION:
8579           case TIMEZONE_ABBR:
8580           case TIMEZONE_MINUTE:
8581           case TIMEZONE_HOUR:
8582           case TRANSACTION:
8583           case TRUE:
8584           case TYPE:
8585           case UNDER:
8586           case USING:
8587           case WHILE:
8588           case YES:
8589           case SHOW:
8590           case A:
8591           case UPDATE:
8592           case DOUBLE:
8593           case DEC:
8594           case PRECISION:
8595           case INT:
8596           case NUMERIC:
8597           case NCHAR:
8598           case NVARCHAR2:
8599           case STRING:
8600           case UROWID:
8601           case VARRAY:
8602           case VARYING:
8603           case BFILE:
8604           case BLOB:
8605           case CLOB:
8606           case NCLOB:
8607           case YEAR:
8608           case LOCAL:
8609           case WITH:
8610           case ZONE:
8611           case CHARACTER:
8612           case AFTER:
8613           case BEFORE:
8614           case OLD:
8615           case PARENT:
8616           case CC_IF:
8617           case CC_ERROR:
8618           case ANALYZE:
8619           case ASSOCIATE:
8620           case AUDIT:
8621           case COMPOUND:
8622           case DATABASE:
8623           case CALL:
8624           case DDL:
8625           case DISASSOCIATE:
8626           case EACH:
8627           case FOLLOWS:
8628           case LOGOFF:
8629           case LOGON:
8630           case NESTED:
8631           case NOAUDIT:
8632           case SCHEMA:
8633           case SERVERERROR:
8634           case SHUTDOWN:
8635           case STARTUP:
8636           case STATEMENT:
8637           case STATISTICS:
8638           case SUSPEND:
8639           case TRUNCATE:
8640           case WRAPPED:
8641           case LIBRARY:
8642           case NAME:
8643           case STRUCT:
8644           case CONTEXT:
8645           case PARAMETERS:
8646           case LENGTH:
8647           case TDO:
8648           case MAXLEN:
8649           case CHARSETID:
8650           case CHARSETFORM:
8651           case ACCEPT:
8652           case ACCESSIBLE:
8653           case COPY:
8654           case DEFINE:
8655           case DISCONNECT:
8656           case HOST:
8657           case PRINT:
8658           case QUIT:
8659           case REMARK:
8660           case UNDEFINE:
8661           case VARIABLE:
8662           case WHENEVER:
8663           case ATTACH:
8664           case CAST:
8665           case TREAT:
8666           case TRIM:
8667           case LEFT:
8668           case RIGHT:
8669           case BOTH:
8670           case EMPTY:
8671           case MULTISET:
8672           case SUBMULTISET:
8673           case LEADING:
8674           case TRAILING:
8675           case CHAR_CS:
8676           case NCHAR_CS:
8677           case DBTIMEZONE:
8678           case SESSIONTIMEZONE:
8679           case AUTHENTICATED:
8680           case LINK:
8681           case SHARED:
8682           case DIRECTORY:
8683           case USER:
8684           case IDENTIFIER:
8685           case UNSIGNED_NUMERIC_LITERAL:
8686           case CHARACTER_LITERAL:
8687           case STRING_LITERAL:
8688           case QUOTED_LITERAL:
8689             ;
8690             break;
8691           default:
8692             jj_la1[116] = jj_gen;
8693             break label_22;
8694           }
8695         }
8696       }
8697       switch (jj_nt.kind) {
8698       case WHEN:
8699         jj_consume_token(WHEN);
8700         jj_consume_token(OTHERS);
8701         jj_consume_token(THEN);
8702         label_23:
8703         while (true) {
8704           Statement();
8705           switch (jj_nt.kind) {
8706           case 5:
8707           case 16:
8708           case 17:
8709           case 21:
8710           case REPLACE:
8711           case DEFINER:
8712           case CURRENT_USER:
8713           case LANGUAGE:
8714           case INLINE:
8715           case ADD:
8716           case AGGREGATE:
8717           case ARRAY:
8718           case AT:
8719           case ATTRIBUTE:
8720           case AUTHID:
8721           case BEGIN:
8722           case BODY:
8723           case BULK:
8724           case BYTE:
8725           case CASCADE:
8726           case CASE:
8727           case CLOSE:
8728           case COALESCE:
8729           case COLLECT:
8730           case COLUMN:
8731           case COMMENT:
8732           case COMMIT:
8733           case CONSTRUCTOR:
8734           case CONTINUE:
8735           case CONVERT:
8736           case CURRENT:
8737           case CURSOR:
8738           case DATA:
8739           case DATE:
8740           case DAY:
8741           case DECLARE:
8742           case DELETE:
8743           case DISABLE:
8744           case EDITIONABLE:
8745           case ELEMENT:
8746           case ENABLE:
8747           case ESCAPE:
8748           case EXCEPT:
8749           case EXCEPTIONS:
8750           case EXECUTE:
8751           case EXIT:
8752           case EXTERNAL:
8753           case EXTENDS:
8754           case EXTRACT:
8755           case FALSE:
8756           case FETCH:
8757           case FINAL:
8758           case FOR:
8759           case FORALL:
8760           case FORCE:
8761           case FUNCTION:
8762           case GLOBAL:
8763           case GOTO:
8764           case HASH:
8765           case HEAP:
8766           case HOUR:
8767           case IF:
8768           case IMMEDIATE:
8769           case INDICES:
8770           case INDEXTYPE:
8771           case INDICATOR:
8772           case INSERT:
8773           case INSTANTIABLE:
8774           case INTERVAL:
8775           case INVALIDATE:
8776           case ISOLATION:
8777           case JAVA:
8778           case LEVEL:
8779           case LIMIT:
8780           case LOCK:
8781           case LOOP:
8782           case MAP:
8783           case MAX:
8784           case MEMBER:
8785           case MERGE:
8786           case MIN:
8787           case MINUTE:
8788           case MLSLABEL:
8789           case MODIFY:
8790           case MOD:
8791           case MONTH:
8792           case NATURAL:
8793           case NEW:
8794           case NEW_DOT:
8795           case NO:
8796           case NONEDITIONABLE:
8797           case NOT:
8798           case NULL:
8799           case NULLIF:
8800           case OBJECT:
8801           case OID:
8802           case OPAQUE:
8803           case OPEN:
8804           case OPERATOR:
8805           case ORGANIZATION:
8806           case OTHERS:
8807           case OVERRIDING:
8808           case PACKAGE:
8809           case PARTITION:
8810           case PIPE:
8811           case PRAGMA:
8812           case PRESERVE:
8813           case PRIVATE:
8814           case PROCEDURE:
8815           case RAISE:
8816           case RANGE:
8817           case RAW:
8818           case REAL:
8819           case RECORD:
8820           case REF:
8821           case RELEASE:
8822           case RELIES_ON:
8823           case RENAME:
8824           case RESULT:
8825           case RETURN:
8826           case RETURNING:
8827           case REVERSE:
8828           case ROLLBACK:
8829           case ROW:
8830           case ROWS:
8831           case ROWID:
8832           case ROWNUM:
8833           case SAVE:
8834           case SAVEPOINT:
8835           case SECOND:
8836           case SELECT:
8837           case SELF:
8838           case SET:
8839           case SPACE:
8840           case SQL:
8841           case SQLCODE:
8842           case SQLERRM:
8843           case STATIC:
8844           case SUBTYPE:
8845           case SUBSTITUTABLE:
8846           case SUCCESSFUL:
8847           case SYSDATE:
8848           case SYS_REFCURSOR:
8849           case TEMPORARY:
8850           case TIME:
8851           case TIMESTAMP:
8852           case TIMEZONE_REGION:
8853           case TIMEZONE_ABBR:
8854           case TIMEZONE_MINUTE:
8855           case TIMEZONE_HOUR:
8856           case TRANSACTION:
8857           case TRUE:
8858           case TYPE:
8859           case UNDER:
8860           case USING:
8861           case WHILE:
8862           case YES:
8863           case SHOW:
8864           case A:
8865           case UPDATE:
8866           case DOUBLE:
8867           case DEC:
8868           case PRECISION:
8869           case INT:
8870           case NUMERIC:
8871           case NCHAR:
8872           case NVARCHAR2:
8873           case STRING:
8874           case UROWID:
8875           case VARRAY:
8876           case VARYING:
8877           case BFILE:
8878           case BLOB:
8879           case CLOB:
8880           case NCLOB:
8881           case YEAR:
8882           case LOCAL:
8883           case WITH:
8884           case ZONE:
8885           case CHARACTER:
8886           case AFTER:
8887           case BEFORE:
8888           case OLD:
8889           case PARENT:
8890           case CC_IF:
8891           case CC_ERROR:
8892           case ANALYZE:
8893           case ASSOCIATE:
8894           case AUDIT:
8895           case COMPOUND:
8896           case DATABASE:
8897           case CALL:
8898           case DDL:
8899           case DISASSOCIATE:
8900           case EACH:
8901           case FOLLOWS:
8902           case LOGOFF:
8903           case LOGON:
8904           case NESTED:
8905           case NOAUDIT:
8906           case SCHEMA:
8907           case SERVERERROR:
8908           case SHUTDOWN:
8909           case STARTUP:
8910           case STATEMENT:
8911           case STATISTICS:
8912           case SUSPEND:
8913           case TRUNCATE:
8914           case WRAPPED:
8915           case LIBRARY:
8916           case NAME:
8917           case STRUCT:
8918           case CONTEXT:
8919           case PARAMETERS:
8920           case LENGTH:
8921           case TDO:
8922           case MAXLEN:
8923           case CHARSETID:
8924           case CHARSETFORM:
8925           case ACCEPT:
8926           case ACCESSIBLE:
8927           case COPY:
8928           case DEFINE:
8929           case DISCONNECT:
8930           case HOST:
8931           case PRINT:
8932           case QUIT:
8933           case REMARK:
8934           case UNDEFINE:
8935           case VARIABLE:
8936           case WHENEVER:
8937           case ATTACH:
8938           case CAST:
8939           case TREAT:
8940           case TRIM:
8941           case LEFT:
8942           case RIGHT:
8943           case BOTH:
8944           case EMPTY:
8945           case MULTISET:
8946           case SUBMULTISET:
8947           case LEADING:
8948           case TRAILING:
8949           case CHAR_CS:
8950           case NCHAR_CS:
8951           case DBTIMEZONE:
8952           case SESSIONTIMEZONE:
8953           case AUTHENTICATED:
8954           case LINK:
8955           case SHARED:
8956           case DIRECTORY:
8957           case USER:
8958           case IDENTIFIER:
8959           case UNSIGNED_NUMERIC_LITERAL:
8960           case CHARACTER_LITERAL:
8961           case STRING_LITERAL:
8962           case QUOTED_LITERAL:
8963             ;
8964             break;
8965           default:
8966             jj_la1[117] = jj_gen;
8967             break label_23;
8968           }
8969         }
8970         break;
8971       default:
8972         jj_la1[118] = jj_gen;
8973         ;
8974       }
8975         jjtree.closeNodeScope(jjtn000, true);
8976         jjtc000 = false;
8977         {if (true) return jjtn000 ;}
8978     } catch (Throwable jjte000) {
8979         if (jjtc000) {
8980           jjtree.clearNodeScope(jjtn000);
8981           jjtc000 = false;
8982         } else {
8983           jjtree.popNode();
8984         }
8985         if (jjte000 instanceof RuntimeException) {
8986           {if (true) throw (RuntimeException)jjte000;}
8987         }
8988         if (jjte000 instanceof ParseException) {
8989           {if (true) throw (ParseException)jjte000;}
8990         }
8991         {if (true) throw (Error)jjte000;}
8992     } finally {
8993         if (jjtc000) {
8994           jjtree.closeNodeScope(jjtn000, true);
8995         }
8996     }
8997     throw new Error("Missing return statement in function");
8998   }
8999 
9000   final public void Skip2NextTerminator(String initiator,String terminator) throws ParseException {
9001  /*@bgen(jjtree) Skip2NextTerminator */
9002   ASTSkip2NextTerminator jjtn000 = new ASTSkip2NextTerminator(this, JJTSKIP2NEXTTERMINATOR);
9003   boolean jjtc000 = true;
9004   jjtree.openNodeScope(jjtn000);Token t = getToken(1);
9005   int count = (initiator == null) ? 0 : 1;
9006   if(t.image.equals(initiator)) count++;
9007   while (count > 0 || !t.image.equals(terminator))
9008   {
9009     t = getNextToken();
9010     t = getToken(1);
9011           if(t.image.equals(initiator)) count++;
9012           if(t.image.equals(terminator)) count--;
9013           if(null != t.specialToken || t.kind == EOF)
9014             return;
9015   }
9016     try {
9017           jjtree.closeNodeScope(jjtn000, true);
9018           jjtc000 = false;
9019           {if (true) return;}
9020     } finally {
9021           if (jjtc000) {
9022             jjtree.closeNodeScope(jjtn000, true);
9023           }
9024     }
9025   }
9026 
9027 /*
9028  Read Tokens up to but not including the target String. 
9029 */
9030   final public void Skip2NextOccurrence(String target) throws ParseException {
9031  /*@bgen(jjtree) Skip2NextOccurrence */
9032   ASTSkip2NextOccurrence jjtn000 = new ASTSkip2NextOccurrence(this, JJTSKIP2NEXTOCCURRENCE);
9033   boolean jjtc000 = true;
9034   jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9035   while (!nextToken.image.equals(target)
9036          && (null == nextToken.specialToken || !nextToken.specialToken.image.equals(target) ) //In case the target is a Special Token
9037          && nextToken.kind!=EOF //SRT 20110521 - Prevent endless loop when target does not exist in the input stream
9038         )
9039   {
9040     nextToken = getNextToken();
9041     nextToken = getToken(1);
9042   }
9043     try {
9044           jjtree.closeNodeScope(jjtn000, true);
9045           jjtc000 = false;
9046           {if (true) return;}
9047     } finally {
9048           if (jjtc000) {
9049             jjtree.closeNodeScope(jjtn000, true);
9050           }
9051     }
9052   }
9053 
9054 /*
9055  Read Tokens up to and including the target String. 
9056 */
9057   final public void SkipPastNextOccurrence(String target) throws ParseException {
9058  /*@bgen(jjtree) SkipPastNextOccurrence */
9059   ASTSkipPastNextOccurrence jjtn000 = new ASTSkipPastNextOccurrence(this, JJTSKIPPASTNEXTOCCURRENCE);
9060   boolean jjtc000 = true;
9061   jjtree.openNodeScope(jjtn000);Token t = null;
9062   Skip2NextOccurrence(target) ;
9063   t = getNextToken();
9064     try {
9065           jjtree.closeNodeScope(jjtn000, true);
9066           jjtc000 = false;
9067           {if (true) return;}
9068     } finally {
9069           if (jjtc000) {
9070             jjtree.closeNodeScope(jjtn000, true);
9071           }
9072     }
9073   }
9074 
9075 /*
9076  Read Tokens up to but not including the target Token.kind. 
9077 */
9078   final public void Skip2NextTokenOccurrence(int target) throws ParseException {
9079  /*@bgen(jjtree) Skip2NextTokenOccurrence */
9080   ASTSkip2NextTokenOccurrence jjtn000 = new ASTSkip2NextTokenOccurrence(this, JJTSKIP2NEXTTOKENOCCURRENCE);
9081   boolean jjtc000 = true;
9082   jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9083   Token specToken = null ;
9084   while (nextToken.kind!=target
9085          && (null == nextToken.specialToken || nextToken.specialToken.kind!=target ) //In case the target is a Special Token
9086          && nextToken.kind!=EOF //SRT 20110521 - Prevent endless loop when target does not exist in the input stream
9087         )
9088   {
9089     /*
9090 	Check if the target appears as a SpecialToken 
9091 
9092 
9093 	nextToken.specialToken points to the _LAST_ of any SpecialTokens before the current normal Token.
9094 
9095 	It is the head of a doubly-linked list:
9096 
9097 	The ${specialToken}.specialToken field POINTS BACKWARDS TOWARDS the FIRST occurring SpecialToken
9098 	The ${specialToken}.next field POINTS FORWARDS to to the LAST occurring SpecialToken
9099 
9100 	This means that if the program is interested in a specific SpecialToken, it must examine the linked list for every Token which has nexToken.specialToken != null.
9101     
9102     */
9103     specToken = nextToken.specialToken;
9104     if (null!= specToken)
9105     {
9106         //Walk backwards through the list looking for this Token as a Special Token 
9107         while (specToken != null && specToken.kind != target)
9108         {
9109                 specToken = specToken.specialToken;
9110         }
9111 
9112         //We have found the target as a SpecialToken - break out of normal Token search
9113         if (null != specToken && specToken.kind == target)
9114         {
9115                 break;
9116         }
9117     }
9118 
9119     nextToken = getNextToken();
9120     nextToken = getToken(1);
9121   }
9122     try {
9123           jjtree.closeNodeScope(jjtn000, true);
9124           jjtc000 = false;
9125           {if (true) return;}
9126     } finally {
9127           if (jjtc000) {
9128             jjtree.closeNodeScope(jjtn000, true);
9129           }
9130     }
9131   }
9132 
9133 /*
9134  Read Tokens up to and including the target Token.kind. 
9135 */
9136   final public void SkipPastNextTokenOccurrence(int target) throws ParseException {
9137  /*@bgen(jjtree) SkipPastNextTokenOccurrence */
9138   ASTSkipPastNextTokenOccurrence jjtn000 = new ASTSkipPastNextTokenOccurrence(this, JJTSKIPPASTNEXTTOKENOCCURRENCE);
9139   boolean jjtc000 = true;
9140   jjtree.openNodeScope(jjtn000);Token t = null;
9141   Skip2NextTokenOccurrence(target) ;
9142   t = getNextToken();
9143     try {
9144           jjtree.closeNodeScope(jjtn000, true);
9145           jjtc000 = false;
9146           {if (true) return;}
9147     } finally {
9148           if (jjtc000) {
9149             jjtree.closeNodeScope(jjtn000, true);
9150           }
9151     }
9152   }
9153 
9154 /*
9155  Read Tokens up to but not including the target String. 
9156 */
9157   final public ASTRead2NextOccurrence Read2NextOccurrence(String target) throws ParseException {
9158  /*@bgen(jjtree) Read2NextOccurrence */
9159   ASTRead2NextOccurrence jjtn000 = new ASTRead2NextOccurrence(this, JJTREAD2NEXTOCCURRENCE);
9160   boolean jjtc000 = true;
9161   jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9162   Token nextToken = getToken(1);
9163   while (!nextToken.image.equals(target)
9164          && nextToken.kind!=EOF
9165         )
9166   {
9167     nextToken = getNextToken();
9168     sb.append(nextToken.image);
9169     nextToken = getToken(1);
9170   }
9171     try {
9172           jjtree.closeNodeScope(jjtn000, true);
9173           jjtc000 = false;
9174           jjtn000.setImage(sb.toString()) ;  jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9175     } finally {
9176           if (jjtc000) {
9177             jjtree.closeNodeScope(jjtn000, true);
9178           }
9179     }
9180     throw new Error("Missing return statement in function");
9181   }
9182 
9183 /*
9184  Read Tokens up to and including the target String. 
9185 */
9186   final public ASTReadPastNextOccurrence ReadPastNextOccurrence(String target) throws ParseException {
9187  /*@bgen(jjtree) ReadPastNextOccurrence */
9188   ASTReadPastNextOccurrence jjtn000 = new ASTReadPastNextOccurrence(this, JJTREADPASTNEXTOCCURRENCE);
9189   boolean jjtc000 = true;
9190   jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9191   Token t = null;
9192   sb.append(Read2NextOccurrence(target)) ;
9193   t = getNextToken(); // Chomp this one 
9194   sb.append(t.image);
9195     try {
9196           jjtree.closeNodeScope(jjtn000, true);
9197           jjtc000 = false;
9198           jjtn000.setImage(sb.toString()) ;  jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9199     } finally {
9200           if (jjtc000) {
9201             jjtree.closeNodeScope(jjtn000, true);
9202           }
9203     }
9204     throw new Error("Missing return statement in function");
9205   }
9206 
9207 /**
9208  * 2006-05-24 - Matthias Hendler - added MERGE
9209  */
9210   final public ASTSqlStatement SqlStatement(String initiator, String terminator) throws ParseException {
9211  /*@bgen(jjtree) SqlStatement */
9212   ASTSqlStatement jjtn000 = new ASTSqlStatement(this, JJTSQLSTATEMENT);
9213   boolean jjtc000 = true;
9214   jjtree.openNodeScope(jjtn000);
9215     try {
9216       switch (jj_nt.kind) {
9217       case SELECT:
9218         jj_consume_token(SELECT);
9219         break;
9220       case UPDATE:
9221         jj_consume_token(UPDATE);
9222         break;
9223       case INSERT:
9224         jj_consume_token(INSERT);
9225         break;
9226       case DELETE:
9227         jj_consume_token(DELETE);
9228         break;
9229       case COMMIT:
9230         jj_consume_token(COMMIT);
9231         break;
9232       case ROLLBACK:
9233         jj_consume_token(ROLLBACK);
9234         break;
9235       case SAVEPOINT:
9236         jj_consume_token(SAVEPOINT);
9237         break;
9238       case EXECUTE:
9239         jj_consume_token(EXECUTE);
9240         break;
9241       case SET:
9242         jj_consume_token(SET);
9243         jj_consume_token(TRANSACTION);
9244         break;
9245       case LOCK:
9246         jj_consume_token(LOCK);
9247         jj_consume_token(TABLE);
9248         break;
9249       case MERGE:
9250         jj_consume_token(MERGE);
9251         break;
9252       case WITH:
9253         jj_consume_token(WITH);
9254         break;
9255       default:
9256         jj_la1[119] = jj_gen;
9257         jj_consume_token(-1);
9258         throw new ParseException();
9259       }
9260       Skip2NextTerminator(initiator,terminator);
9261           jjtree.closeNodeScope(jjtn000, true);
9262           jjtc000 = false;
9263           {if (true) return jjtn000 ;}
9264     } catch (Throwable jjte000) {
9265           if (jjtc000) {
9266             jjtree.clearNodeScope(jjtn000);
9267             jjtc000 = false;
9268           } else {
9269             jjtree.popNode();
9270           }
9271           if (jjte000 instanceof RuntimeException) {
9272             {if (true) throw (RuntimeException)jjte000;}
9273           }
9274           if (jjte000 instanceof ParseException) {
9275             {if (true) throw (ParseException)jjte000;}
9276           }
9277           {if (true) throw (Error)jjte000;}
9278     } finally {
9279           if (jjtc000) {
9280             jjtree.closeNodeScope(jjtn000, true);
9281           }
9282     }
9283     throw new Error("Missing return statement in function");
9284   }
9285 
9286 /**
9287  * 2011-05-15 - SRT - Added to cope with wrapped objects
9288   A wrapped function looks like this (always terminated by one or more equals signs "="):-
9289   "  CREATE OR REPLACE FUNCTION "TESTUSER"."GET_DATE_STRING"
9290 / ** Return SYSDATE formatted using the provided template.
9291  *
9292  *
9293  *  @param p_date_format normal TO_CHARE/TO_DATE date template
9294  *  @return formatted datestring
9295  *  @see http://www.oracle-base.com/articles/10g/WrapAndDBMS_DDL_10gR2.php#dbms_ddl
9296  * /
9297 wrapped
9298 a000000
9299 369
9300 abcd
9301 abcd
9302 abcd
9303 abcd
9304 abcd
9305 abcd
9306 abcd
9307 abcd
9308 abcd
9309 abcd
9310 abcd
9311 abcd
9312 abcd
9313 abcd
9314 abcd
9315 8
9316 89 b6
9317 /SBrhM8+1iUO4QAih+qD2SK8kSowg8eZgcfLCNL+XlquYvSuoVah8JbRPpdHDLHn479SdFLw
9318 v04omzJ0zOfHdMAzuHQlw+fAsr2ym9YI8I521pRTbnFVAHOOUw4JqPkIyj7wj4VwyL17nhYb
9319 3qPVuL6SvhZTmEBnRtaErHpzaDuIpqZ0G4s=
9320   "
9321  */
9322   final public void WrappedObject() throws ParseException {
9323  /*@bgen(jjtree) WrappedObject */
9324   ASTWrappedObject jjtn000 = new ASTWrappedObject(this, JJTWRAPPEDOBJECT);
9325   boolean jjtc000 = true;
9326   jjtree.openNodeScope(jjtn000);
9327     try {
9328       jj_consume_token(WRAPPED);
9329           jjtree.closeNodeScope(jjtn000, true);
9330           jjtc000 = false;
9331            Token nextToken;
9332 
9333                 nextToken = getToken(1); //ReadAhead
9334                 while (
9335                      null != nextToken && nextToken.kind!=EOF
9336                      )
9337                 {
9338                         nextToken = getNextToken();
9339 
9340                         //Execute manual readahead 
9341                         nextToken = getToken(1); //ReadAhead 1 Token 
9342                 }
9343                 {if (true) return;}
9344     } finally {
9345           if (jjtc000) {
9346             jjtree.closeNodeScope(jjtn000, true);
9347           }
9348     }
9349   }
9350 
9351 // ============================================================================
9352 // S T A T E M E N T S
9353 // ============================================================================
9354 
9355 /**
9356  * 2006-05-24 - Matthias Hendler - added MERGE, EXECUTE choice and LOOKAHEAD at <LOOP>
9357  */
9358   final public ASTUnlabelledStatement UnlabelledStatement() throws ParseException {
9359  /*@bgen(jjtree) UnlabelledStatement */
9360   ASTUnlabelledStatement jjtn000 = new ASTUnlabelledStatement(this, JJTUNLABELLEDSTATEMENT);
9361   boolean jjtc000 = true;
9362   jjtree.openNodeScope(jjtn000);
9363     try {
9364       if (jj_2_42(2147483647)) {
9365         SqlStatement(null,";");
9366         switch (jj_nt.kind) {
9367         case 4:
9368           jj_consume_token(4);
9369           break;
9370         default:
9371           jj_la1[120] = jj_gen;
9372           ;
9373         }
9374       } else if (jj_2_43(3)) {
9375         ContinueStatement();
9376         jj_consume_token(4);
9377       } else {
9378         switch (jj_nt.kind) {
9379         case CASE:
9380           CaseStatement();
9381           jj_consume_token(4);
9382           break;
9383         case IF:
9384           IfStatement();
9385           jj_consume_token(4);
9386           break;
9387         case FOR:
9388           ForStatement();
9389           jj_consume_token(4);
9390           break;
9391         case FORALL:
9392           ForAllStatement();
9393           jj_consume_token(4);
9394           break;
9395         case LOOP:
9396           LoopStatement();
9397           jj_consume_token(4);
9398           break;
9399         case WHILE:
9400           WhileStatement();
9401           jj_consume_token(4);
9402           break;
9403         case GOTO:
9404           GotoStatement();
9405           jj_consume_token(4);
9406           break;
9407         case RETURN:
9408           ReturnStatement();
9409           jj_consume_token(4);
9410           break;
9411         case EXIT:
9412           ExitStatement();
9413           jj_consume_token(4);
9414           break;
9415         case RAISE:
9416           RaiseStatement();
9417           jj_consume_token(4);
9418           break;
9419         case CLOSE:
9420           CloseStatement();
9421           jj_consume_token(4);
9422           break;
9423         case OPEN:
9424           OpenStatement();
9425           jj_consume_token(4);
9426           break;
9427         case FETCH:
9428           FetchStatement();
9429           jj_consume_token(4);
9430           break;
9431         case BEGIN:
9432         case DECLARE:
9433           Block();
9434           jj_consume_token(4);
9435           break;
9436         case EXECUTE:
9437           EmbeddedSqlStatement();
9438           jj_consume_token(4);
9439           break;
9440         case PIPE:
9441           PipelineStatement();
9442           jj_consume_token(4);
9443           break;
9444         case CC_IF:
9445         case CC_ERROR:
9446           ConditionalCompilationStatement();
9447           break;
9448         case PRAGMA:
9449           InlinePragma();
9450           jj_consume_token(4);
9451           break;
9452         case 5:
9453         case 16:
9454         case 17:
9455         case REPLACE:
9456         case DEFINER:
9457         case CURRENT_USER:
9458         case LANGUAGE:
9459         case INLINE:
9460         case ADD:
9461         case AGGREGATE:
9462         case ARRAY:
9463         case AT:
9464         case ATTRIBUTE:
9465         case AUTHID:
9466         case BODY:
9467         case BULK:
9468         case BYTE:
9469         case CASCADE:
9470         case COALESCE:
9471         case COLLECT:
9472         case COLUMN:
9473         case COMMENT:
9474         case COMMIT:
9475         case CONSTRUCTOR:
9476         case CONTINUE:
9477         case CONVERT:
9478         case CURRENT:
9479         case CURSOR:
9480         case DATA:
9481         case DATE:
9482         case DAY:
9483         case DISABLE:
9484         case EDITIONABLE:
9485         case ELEMENT:
9486         case ENABLE:
9487         case ESCAPE:
9488         case EXCEPT:
9489         case EXCEPTIONS:
9490         case EXTERNAL:
9491         case EXTENDS:
9492         case EXTRACT:
9493         case FALSE:
9494         case FINAL:
9495         case FORCE:
9496         case FUNCTION:
9497         case GLOBAL:
9498         case HASH:
9499         case HEAP:
9500         case HOUR:
9501         case IMMEDIATE:
9502         case INDICES:
9503         case INDEXTYPE:
9504         case INDICATOR:
9505         case INSTANTIABLE:
9506         case INTERVAL:
9507         case INVALIDATE:
9508         case ISOLATION:
9509         case JAVA:
9510         case LEVEL:
9511         case LIMIT:
9512         case MAP:
9513         case MAX:
9514         case MEMBER:
9515         case MERGE:
9516         case MIN:
9517         case MINUTE:
9518         case MLSLABEL:
9519         case MODIFY:
9520         case MOD:
9521         case MONTH:
9522         case NATURAL:
9523         case NEW:
9524         case NEW_DOT:
9525         case NO:
9526         case NONEDITIONABLE:
9527         case NOT:
9528         case NULL:
9529         case NULLIF:
9530         case OBJECT:
9531         case OID:
9532         case OPAQUE:
9533         case OPERATOR:
9534         case ORGANIZATION:
9535         case OTHERS:
9536         case OVERRIDING:
9537         case PACKAGE:
9538         case PARTITION:
9539         case PRESERVE:
9540         case PRIVATE:
9541         case PROCEDURE:
9542         case RANGE:
9543         case RAW:
9544         case REAL:
9545         case RECORD:
9546         case REF:
9547         case RELEASE:
9548         case RELIES_ON:
9549         case RENAME:
9550         case RESULT:
9551         case RETURNING:
9552         case REVERSE:
9553         case ROLLBACK:
9554         case ROW:
9555         case ROWS:
9556         case ROWID:
9557         case ROWNUM:
9558         case SAVE:
9559         case SAVEPOINT:
9560         case SECOND:
9561         case SELECT:
9562         case SELF:
9563         case SET:
9564         case SPACE:
9565         case SQL:
9566         case SQLCODE:
9567         case SQLERRM:
9568         case STATIC:
9569         case SUBTYPE:
9570         case SUBSTITUTABLE:
9571         case SUCCESSFUL:
9572         case SYSDATE:
9573         case SYS_REFCURSOR:
9574         case TEMPORARY:
9575         case TIME:
9576         case TIMESTAMP:
9577         case TIMEZONE_REGION:
9578         case TIMEZONE_ABBR:
9579         case TIMEZONE_MINUTE:
9580         case TIMEZONE_HOUR:
9581         case TRANSACTION:
9582         case TRUE:
9583         case TYPE:
9584         case UNDER:
9585         case USING:
9586         case YES:
9587         case SHOW:
9588         case A:
9589         case DOUBLE:
9590         case DEC:
9591         case PRECISION:
9592         case INT:
9593         case NUMERIC:
9594         case NCHAR:
9595         case NVARCHAR2:
9596         case STRING:
9597         case UROWID:
9598         case VARRAY:
9599         case VARYING:
9600         case BFILE:
9601         case BLOB:
9602         case CLOB:
9603         case NCLOB:
9604         case YEAR:
9605         case LOCAL:
9606         case WITH:
9607         case ZONE:
9608         case CHARACTER:
9609         case AFTER:
9610         case BEFORE:
9611         case OLD:
9612         case PARENT:
9613         case ANALYZE:
9614         case ASSOCIATE:
9615         case AUDIT:
9616         case COMPOUND:
9617         case DATABASE:
9618         case CALL:
9619         case DDL:
9620         case DISASSOCIATE:
9621         case EACH:
9622         case FOLLOWS:
9623         case LOGOFF:
9624         case LOGON:
9625         case NESTED:
9626         case NOAUDIT:
9627         case SCHEMA:
9628         case SERVERERROR:
9629         case SHUTDOWN:
9630         case STARTUP:
9631         case STATEMENT:
9632         case STATISTICS:
9633         case SUSPEND:
9634         case TRUNCATE:
9635         case WRAPPED:
9636         case LIBRARY:
9637         case NAME:
9638         case STRUCT:
9639         case CONTEXT:
9640         case PARAMETERS:
9641         case LENGTH:
9642         case TDO:
9643         case MAXLEN:
9644         case CHARSETID:
9645         case CHARSETFORM:
9646         case ACCEPT:
9647         case ACCESSIBLE:
9648         case COPY:
9649         case DEFINE:
9650         case DISCONNECT:
9651         case HOST:
9652         case PRINT:
9653         case QUIT:
9654         case REMARK:
9655         case UNDEFINE:
9656         case VARIABLE:
9657         case WHENEVER:
9658         case ATTACH:
9659         case CAST:
9660         case TREAT:
9661         case TRIM:
9662         case LEFT:
9663         case RIGHT:
9664         case BOTH:
9665         case EMPTY:
9666         case MULTISET:
9667         case SUBMULTISET:
9668         case LEADING:
9669         case TRAILING:
9670         case CHAR_CS:
9671         case NCHAR_CS:
9672         case DBTIMEZONE:
9673         case SESSIONTIMEZONE:
9674         case AUTHENTICATED:
9675         case LINK:
9676         case SHARED:
9677         case DIRECTORY:
9678         case USER:
9679         case IDENTIFIER:
9680         case UNSIGNED_NUMERIC_LITERAL:
9681         case CHARACTER_LITERAL:
9682         case STRING_LITERAL:
9683         case QUOTED_LITERAL:
9684           Expression();
9685           jj_consume_token(4);
9686           break;
9687         default:
9688           jj_la1[121] = jj_gen;
9689           jj_consume_token(-1);
9690           throw new ParseException();
9691         }
9692       }
9693         jjtree.closeNodeScope(jjtn000, true);
9694         jjtc000 = false;
9695         {if (true) return jjtn000 ;}
9696     } catch (Throwable jjte000) {
9697          if (jjtc000) {
9698            jjtree.clearNodeScope(jjtn000);
9699            jjtc000 = false;
9700          } else {
9701            jjtree.popNode();
9702          }
9703          if (jjte000 instanceof RuntimeException) {
9704            {if (true) throw (RuntimeException)jjte000;}
9705          }
9706          if (jjte000 instanceof ParseException) {
9707            {if (true) throw (ParseException)jjte000;}
9708          }
9709          {if (true) throw (Error)jjte000;}
9710     } finally {
9711          if (jjtc000) {
9712            jjtree.closeNodeScope(jjtn000, true);
9713          }
9714     }
9715     throw new Error("Missing return statement in function");
9716   }
9717 
9718   final public ASTStatement Statement() throws ParseException {
9719  /*@bgen(jjtree) Statement */
9720   ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
9721   boolean jjtc000 = true;
9722   jjtree.openNodeScope(jjtn000);
9723     try {
9724       switch (jj_nt.kind) {
9725       case 21:
9726         LabelledStatement();
9727         break;
9728       case 5:
9729       case 16:
9730       case 17:
9731       case REPLACE:
9732       case DEFINER:
9733       case CURRENT_USER:
9734       case LANGUAGE:
9735       case INLINE:
9736       case ADD:
9737       case AGGREGATE:
9738       case ARRAY:
9739       case AT:
9740       case ATTRIBUTE:
9741       case AUTHID:
9742       case BEGIN:
9743       case BODY:
9744       case BULK:
9745       case BYTE:
9746       case CASCADE:
9747       case CASE:
9748       case CLOSE:
9749       case COALESCE:
9750       case COLLECT:
9751       case COLUMN:
9752       case COMMENT:
9753       case COMMIT:
9754       case CONSTRUCTOR:
9755       case CONTINUE:
9756       case CONVERT:
9757       case CURRENT:
9758       case CURSOR:
9759       case DATA:
9760       case DATE:
9761       case DAY:
9762       case DECLARE:
9763       case DELETE:
9764       case DISABLE:
9765       case EDITIONABLE:
9766       case ELEMENT:
9767       case ENABLE:
9768       case ESCAPE:
9769       case EXCEPT:
9770       case EXCEPTIONS:
9771       case EXECUTE:
9772       case EXIT:
9773       case EXTERNAL:
9774       case EXTENDS:
9775       case EXTRACT:
9776       case FALSE:
9777       case FETCH:
9778       case FINAL:
9779       case FOR:
9780       case FORALL:
9781       case FORCE:
9782       case FUNCTION:
9783       case GLOBAL:
9784       case GOTO:
9785       case HASH:
9786       case HEAP:
9787       case HOUR:
9788       case IF:
9789       case IMMEDIATE:
9790       case INDICES:
9791       case INDEXTYPE:
9792       case INDICATOR:
9793       case INSERT:
9794       case INSTANTIABLE:
9795       case INTERVAL:
9796       case INVALIDATE:
9797       case ISOLATION:
9798       case JAVA:
9799       case LEVEL:
9800       case LIMIT:
9801       case LOCK:
9802       case LOOP:
9803       case MAP:
9804       case MAX:
9805       case MEMBER:
9806       case MERGE:
9807       case MIN:
9808       case MINUTE:
9809       case MLSLABEL:
9810       case MODIFY:
9811       case MOD:
9812       case MONTH:
9813       case NATURAL:
9814       case NEW:
9815       case NEW_DOT:
9816       case NO:
9817       case NONEDITIONABLE:
9818       case NOT:
9819       case NULL:
9820       case NULLIF:
9821       case OBJECT:
9822       case OID:
9823       case OPAQUE:
9824       case OPEN:
9825       case OPERATOR:
9826       case ORGANIZATION:
9827       case OTHERS:
9828       case OVERRIDING:
9829       case PACKAGE:
9830       case PARTITION:
9831       case PIPE:
9832       case PRAGMA:
9833       case PRESERVE:
9834       case PRIVATE:
9835       case PROCEDURE:
9836       case RAISE:
9837       case RANGE:
9838       case RAW:
9839       case REAL:
9840       case RECORD:
9841       case REF:
9842       case RELEASE:
9843       case RELIES_ON:
9844       case RENAME:
9845       case RESULT:
9846       case RETURN:
9847       case RETURNING:
9848       case REVERSE:
9849       case ROLLBACK:
9850       case ROW:
9851       case ROWS:
9852       case ROWID:
9853       case ROWNUM:
9854       case SAVE:
9855       case SAVEPOINT:
9856       case SECOND:
9857       case SELECT:
9858       case SELF:
9859       case SET:
9860       case SPACE:
9861       case SQL:
9862       case SQLCODE:
9863       case SQLERRM:
9864       case STATIC:
9865       case SUBTYPE:
9866       case SUBSTITUTABLE:
9867       case SUCCESSFUL:
9868       case SYSDATE:
9869       case SYS_REFCURSOR:
9870       case TEMPORARY:
9871       case TIME:
9872       case TIMESTAMP:
9873       case TIMEZONE_REGION:
9874       case TIMEZONE_ABBR:
9875       case TIMEZONE_MINUTE:
9876       case TIMEZONE_HOUR:
9877       case TRANSACTION:
9878       case TRUE:
9879       case TYPE:
9880       case UNDER:
9881       case USING:
9882       case WHILE:
9883       case YES:
9884       case SHOW:
9885       case A:
9886       case UPDATE:
9887       case DOUBLE:
9888       case DEC:
9889       case PRECISION:
9890       case INT:
9891       case NUMERIC:
9892       case NCHAR:
9893       case NVARCHAR2:
9894       case STRING:
9895       case UROWID:
9896       case VARRAY:
9897       case VARYING:
9898       case BFILE:
9899       case BLOB:
9900       case CLOB:
9901       case NCLOB:
9902       case YEAR:
9903       case LOCAL:
9904       case WITH:
9905       case ZONE:
9906       case CHARACTER:
9907       case AFTER:
9908       case BEFORE:
9909       case OLD:
9910       case PARENT:
9911       case CC_IF:
9912       case CC_ERROR:
9913       case ANALYZE:
9914       case ASSOCIATE:
9915       case AUDIT:
9916       case COMPOUND:
9917       case DATABASE:
9918       case CALL:
9919       case DDL:
9920       case DISASSOCIATE:
9921       case EACH:
9922       case FOLLOWS:
9923       case LOGOFF:
9924       case LOGON:
9925       case NESTED:
9926       case NOAUDIT:
9927       case SCHEMA:
9928       case SERVERERROR:
9929       case SHUTDOWN:
9930       case STARTUP:
9931       case STATEMENT:
9932       case STATISTICS:
9933       case SUSPEND:
9934       case TRUNCATE:
9935       case WRAPPED:
9936       case LIBRARY:
9937       case NAME:
9938       case STRUCT:
9939       case CONTEXT:
9940       case PARAMETERS:
9941       case LENGTH:
9942       case TDO:
9943       case MAXLEN:
9944       case CHARSETID:
9945       case CHARSETFORM:
9946       case ACCEPT:
9947       case ACCESSIBLE:
9948       case COPY:
9949       case DEFINE:
9950       case DISCONNECT:
9951       case HOST:
9952       case PRINT:
9953       case QUIT:
9954       case REMARK:
9955       case UNDEFINE:
9956       case VARIABLE:
9957       case WHENEVER:
9958       case ATTACH:
9959       case CAST:
9960       case TREAT:
9961       case TRIM:
9962       case LEFT:
9963       case RIGHT:
9964       case BOTH:
9965       case EMPTY:
9966       case MULTISET:
9967       case SUBMULTISET:
9968       case LEADING:
9969       case TRAILING:
9970       case CHAR_CS:
9971       case NCHAR_CS:
9972       case DBTIMEZONE:
9973       case SESSIONTIMEZONE:
9974       case AUTHENTICATED:
9975       case LINK:
9976       case SHARED:
9977       case DIRECTORY:
9978       case USER:
9979       case IDENTIFIER:
9980       case UNSIGNED_NUMERIC_LITERAL:
9981       case CHARACTER_LITERAL:
9982       case STRING_LITERAL:
9983       case QUOTED_LITERAL:
9984         UnlabelledStatement();
9985         break;
9986       default:
9987         jj_la1[122] = jj_gen;
9988         jj_consume_token(-1);
9989         throw new ParseException();
9990       }
9991         jjtree.closeNodeScope(jjtn000, true);
9992         jjtc000 = false;
9993         {if (true) return jjtn000 ;}
9994     } catch (Throwable jjte000) {
9995         if (jjtc000) {
9996           jjtree.clearNodeScope(jjtn000);
9997           jjtc000 = false;
9998         } else {
9999           jjtree.popNode();
10000         }
10001         if (jjte000 instanceof RuntimeException) {
10002           {if (true) throw (RuntimeException)jjte000;}
10003         }
10004         if (jjte000 instanceof ParseException) {
10005           {if (true) throw (ParseException)jjte000;}
10006         }
10007         {if (true) throw (Error)jjte000;}
10008     } finally {
10009         if (jjtc000) {
10010           jjtree.closeNodeScope(jjtn000, true);
10011         }
10012     }
10013     throw new Error("Missing return statement in function");
10014   }
10015 
10016 /*
10017 LabelledStatement created solely to conform with PMD Java AST (for PMD DataFlow Analysis - DFA)
10018 N.B. equivalent Java AST* class is ASTLabeledStatement (single "l" rather than double "ll")
10019 */
10020   final public ASTLabelledStatement LabelledStatement() throws ParseException {
10021  /*@bgen(jjtree) LabelledStatement */
10022 ASTLabelledStatement jjtn000 = new ASTLabelledStatement(this, JJTLABELLEDSTATEMENT);
10023 boolean jjtc000 = true;
10024 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
10025     try {
10026       label_24:
10027       while (true) {
10028         simpleNode = Label();
10029         switch (jj_nt.kind) {
10030         case 21:
10031           ;
10032           break;
10033         default:
10034           jj_la1[123] = jj_gen;
10035           break label_24;
10036         }
10037       }
10038       UnlabelledStatement();
10039         jjtree.closeNodeScope(jjtn000, true);
10040         jjtc000 = false;
10041         jjtn000.setImage( simpleNode.getImage() ) ;
10042        {if (true) return jjtn000 ;}
10043     } catch (Throwable jjte000) {
10044         if (jjtc000) {
10045           jjtree.clearNodeScope(jjtn000);
10046           jjtc000 = false;
10047         } else {
10048           jjtree.popNode();
10049         }
10050         if (jjte000 instanceof RuntimeException) {
10051           {if (true) throw (RuntimeException)jjte000;}
10052         }
10053         if (jjte000 instanceof ParseException) {
10054           {if (true) throw (ParseException)jjte000;}
10055         }
10056         {if (true) throw (Error)jjte000;}
10057     } finally {
10058         if (jjtc000) {
10059           jjtree.closeNodeScope(jjtn000, true);
10060         }
10061     }
10062     throw new Error("Missing return statement in function");
10063   }
10064 
10065   final public ASTCaseStatement CaseStatement() throws ParseException {
10066  /*@bgen(jjtree) CaseStatement */
10067   ASTCaseStatement jjtn000 = new ASTCaseStatement(this, JJTCASESTATEMENT);
10068   boolean jjtc000 = true;
10069   jjtree.openNodeScope(jjtn000);
10070     try {
10071       jj_consume_token(CASE);
10072       switch (jj_nt.kind) {
10073       case 5:
10074       case 16:
10075       case 17:
10076       case REPLACE:
10077       case DEFINER:
10078       case CURRENT_USER:
10079       case LANGUAGE:
10080       case INLINE:
10081       case ADD:
10082       case AGGREGATE:
10083       case ARRAY:
10084       case AT:
10085       case ATTRIBUTE:
10086       case AUTHID:
10087       case BODY:
10088       case BULK:
10089       case BYTE:
10090       case CASCADE:
10091       case CASE:
10092       case CLOSE:
10093       case COALESCE:
10094       case COLLECT:
10095       case COLUMN:
10096       case COMMENT:
10097       case COMMIT:
10098       case CONSTRUCTOR:
10099       case CONTINUE:
10100       case CONVERT:
10101       case CURRENT:
10102       case CURSOR:
10103       case DATA:
10104       case DATE:
10105       case DAY:
10106       case DISABLE:
10107       case EDITIONABLE:
10108       case ELEMENT:
10109       case ENABLE:
10110       case ESCAPE:
10111       case EXCEPT:
10112       case EXCEPTIONS:
10113       case EXIT:
10114       case EXTERNAL:
10115       case EXTENDS:
10116       case EXTRACT:
10117       case FALSE:
10118       case FINAL:
10119       case FORCE:
10120       case FUNCTION:
10121       case GLOBAL:
10122       case HASH:
10123       case HEAP:
10124       case HOUR:
10125       case IMMEDIATE:
10126       case INDICES:
10127       case INDEXTYPE:
10128       case INDICATOR:
10129       case INSTANTIABLE:
10130       case INTERVAL:
10131       case INVALIDATE:
10132       case ISOLATION:
10133       case JAVA:
10134       case LEVEL:
10135       case LIMIT:
10136       case LOOP:
10137       case MAP:
10138       case MAX:
10139       case MEMBER:
10140       case MERGE:
10141       case MIN:
10142       case MINUTE:
10143       case MLSLABEL:
10144       case MODIFY:
10145       case MOD:
10146       case MONTH:
10147       case NATURAL:
10148       case NEW:
10149       case NEW_DOT:
10150       case NO:
10151       case NONEDITIONABLE:
10152       case NOT:
10153       case NULL:
10154       case NULLIF:
10155       case OBJECT:
10156       case OID:
10157       case OPAQUE:
10158       case OPEN:
10159       case OPERATOR:
10160       case ORGANIZATION:
10161       case OTHERS:
10162       case OVERRIDING:
10163       case PACKAGE:
10164       case PARTITION:
10165       case PRESERVE:
10166       case PRIVATE:
10167       case PROCEDURE:
10168       case RANGE:
10169       case RAW:
10170       case REAL:
10171       case RECORD:
10172       case REF:
10173       case RELEASE:
10174       case RELIES_ON:
10175       case RENAME:
10176       case RESULT:
10177       case RETURN:
10178       case RETURNING:
10179       case REVERSE:
10180       case ROLLBACK:
10181       case ROW:
10182       case ROWS:
10183       case ROWID:
10184       case ROWNUM:
10185       case SAVE:
10186       case SAVEPOINT:
10187       case SECOND:
10188       case SELECT:
10189       case SELF:
10190       case SET:
10191       case SPACE:
10192       case SQL:
10193       case SQLCODE:
10194       case SQLERRM:
10195       case STATIC:
10196       case SUBTYPE:
10197       case SUBSTITUTABLE:
10198       case SUCCESSFUL:
10199       case SYSDATE:
10200       case SYS_REFCURSOR:
10201       case TEMPORARY:
10202       case TIME:
10203       case TIMESTAMP:
10204       case TIMEZONE_REGION:
10205       case TIMEZONE_ABBR:
10206       case TIMEZONE_MINUTE:
10207       case TIMEZONE_HOUR:
10208       case TRANSACTION:
10209       case TRUE:
10210       case TYPE:
10211       case UNDER:
10212       case USING:
10213       case YES:
10214       case SHOW:
10215       case A:
10216       case DOUBLE:
10217       case DEC:
10218       case PRECISION:
10219       case INT:
10220       case NUMERIC:
10221       case NCHAR:
10222       case NVARCHAR2:
10223       case STRING:
10224       case UROWID:
10225       case VARRAY:
10226       case VARYING:
10227       case BFILE:
10228       case BLOB:
10229       case CLOB:
10230       case NCLOB:
10231       case YEAR:
10232       case LOCAL:
10233       case WITH:
10234       case ZONE:
10235       case CHARACTER:
10236       case AFTER:
10237       case BEFORE:
10238       case OLD:
10239       case PARENT:
10240       case CC_IF:
10241       case ANALYZE:
10242       case ASSOCIATE:
10243       case AUDIT:
10244       case COMPOUND:
10245       case DATABASE:
10246       case CALL:
10247       case DDL:
10248       case DISASSOCIATE:
10249       case EACH:
10250       case FOLLOWS:
10251       case LOGOFF:
10252       case LOGON:
10253       case NESTED:
10254       case NOAUDIT:
10255       case SCHEMA:
10256       case SERVERERROR:
10257       case SHUTDOWN:
10258       case STARTUP:
10259       case STATEMENT:
10260       case STATISTICS:
10261       case SUSPEND:
10262       case TRUNCATE:
10263       case WRAPPED:
10264       case LIBRARY:
10265       case NAME:
10266       case STRUCT:
10267       case CONTEXT:
10268       case PARAMETERS:
10269       case LENGTH:
10270       case TDO:
10271       case MAXLEN:
10272       case CHARSETID:
10273       case CHARSETFORM:
10274       case ACCEPT:
10275       case ACCESSIBLE:
10276       case COPY:
10277       case DEFINE:
10278       case DISCONNECT:
10279       case HOST:
10280       case PRINT:
10281       case QUIT:
10282       case REMARK:
10283       case UNDEFINE:
10284       case VARIABLE:
10285       case WHENEVER:
10286       case ATTACH:
10287       case CAST:
10288       case TREAT:
10289       case TRIM:
10290       case LEFT:
10291       case RIGHT:
10292       case BOTH:
10293       case EMPTY:
10294       case MULTISET:
10295       case SUBMULTISET:
10296       case LEADING:
10297       case TRAILING:
10298       case CHAR_CS:
10299       case NCHAR_CS:
10300       case DBTIMEZONE:
10301       case SESSIONTIMEZONE:
10302       case AUTHENTICATED:
10303       case LINK:
10304       case SHARED:
10305       case DIRECTORY:
10306       case USER:
10307       case IDENTIFIER:
10308       case UNSIGNED_NUMERIC_LITERAL:
10309       case CHARACTER_LITERAL:
10310       case STRING_LITERAL:
10311       case QUOTED_LITERAL:
10312         Expression();
10313         break;
10314       default:
10315         jj_la1[124] = jj_gen;
10316         ;
10317       }
10318       label_25:
10319       while (true) {
10320         switch (jj_nt.kind) {
10321         case WHEN:
10322           ;
10323           break;
10324         default:
10325           jj_la1[125] = jj_gen;
10326           break label_25;
10327         }
10328         CaseWhenClause();
10329       }
10330       switch (jj_nt.kind) {
10331       case ELSE:
10332         ElseClause();
10333         break;
10334       default:
10335         jj_la1[126] = jj_gen;
10336         ;
10337       }
10338       jj_consume_token(END);
10339       jj_consume_token(CASE);
10340       switch (jj_nt.kind) {
10341       case IDENTIFIER:
10342         jj_consume_token(IDENTIFIER);
10343         break;
10344       default:
10345         jj_la1[127] = jj_gen;
10346         ;
10347       }
10348         jjtree.closeNodeScope(jjtn000, true);
10349         jjtc000 = false;
10350         {if (true) return jjtn000 ;}
10351     } catch (Throwable jjte000) {
10352          if (jjtc000) {
10353            jjtree.clearNodeScope(jjtn000);
10354            jjtc000 = false;
10355          } else {
10356            jjtree.popNode();
10357          }
10358          if (jjte000 instanceof RuntimeException) {
10359            {if (true) throw (RuntimeException)jjte000;}
10360          }
10361          if (jjte000 instanceof ParseException) {
10362            {if (true) throw (ParseException)jjte000;}
10363          }
10364          {if (true) throw (Error)jjte000;}
10365     } finally {
10366          if (jjtc000) {
10367            jjtree.closeNodeScope(jjtn000, true);
10368          }
10369     }
10370     throw new Error("Missing return statement in function");
10371   }
10372 
10373   final public ASTCaseWhenClause CaseWhenClause() throws ParseException {
10374  /*@bgen(jjtree) CaseWhenClause */
10375   ASTCaseWhenClause jjtn000 = new ASTCaseWhenClause(this, JJTCASEWHENCLAUSE);
10376   boolean jjtc000 = true;
10377   jjtree.openNodeScope(jjtn000);
10378     try {
10379       jj_consume_token(WHEN);
10380       Expression();
10381       jj_consume_token(THEN);
10382       label_26:
10383       while (true) {
10384         Statement();
10385         switch (jj_nt.kind) {
10386         case 5:
10387         case 16:
10388         case 17:
10389         case 21:
10390         case REPLACE:
10391         case DEFINER:
10392         case CURRENT_USER:
10393         case LANGUAGE:
10394         case INLINE:
10395         case ADD:
10396         case AGGREGATE:
10397         case ARRAY:
10398         case AT:
10399         case ATTRIBUTE:
10400         case AUTHID:
10401         case BEGIN:
10402         case BODY:
10403         case BULK:
10404         case BYTE:
10405         case CASCADE:
10406         case CASE:
10407         case CLOSE:
10408         case COALESCE:
10409         case COLLECT:
10410         case COLUMN:
10411         case COMMENT:
10412         case COMMIT:
10413         case CONSTRUCTOR:
10414         case CONTINUE:
10415         case CONVERT:
10416         case CURRENT:
10417         case CURSOR:
10418         case DATA:
10419         case DATE:
10420         case DAY:
10421         case DECLARE:
10422         case DELETE:
10423         case DISABLE:
10424         case EDITIONABLE:
10425         case ELEMENT:
10426         case ENABLE:
10427         case ESCAPE:
10428         case EXCEPT:
10429         case EXCEPTIONS:
10430         case EXECUTE:
10431         case EXIT:
10432         case EXTERNAL:
10433         case EXTENDS:
10434         case EXTRACT:
10435         case FALSE:
10436         case FETCH:
10437         case FINAL:
10438         case FOR:
10439         case FORALL:
10440         case FORCE:
10441         case FUNCTION:
10442         case GLOBAL:
10443         case GOTO:
10444         case HASH:
10445         case HEAP:
10446         case HOUR:
10447         case IF:
10448         case IMMEDIATE:
10449         case INDICES:
10450         case INDEXTYPE:
10451         case INDICATOR:
10452         case INSERT:
10453         case INSTANTIABLE:
10454         case INTERVAL:
10455         case INVALIDATE:
10456         case ISOLATION:
10457         case JAVA:
10458         case LEVEL:
10459         case LIMIT:
10460         case LOCK:
10461         case LOOP:
10462         case MAP:
10463         case MAX:
10464         case MEMBER:
10465         case MERGE:
10466         case MIN:
10467         case MINUTE:
10468         case MLSLABEL:
10469         case MODIFY:
10470         case MOD:
10471         case MONTH:
10472         case NATURAL:
10473         case NEW:
10474         case NEW_DOT:
10475         case NO:
10476         case NONEDITIONABLE:
10477         case NOT:
10478         case NULL:
10479         case NULLIF:
10480         case OBJECT:
10481         case OID:
10482         case OPAQUE:
10483         case OPEN:
10484         case OPERATOR:
10485         case ORGANIZATION:
10486         case OTHERS:
10487         case OVERRIDING:
10488         case PACKAGE:
10489         case PARTITION:
10490         case PIPE:
10491         case PRAGMA:
10492         case PRESERVE:
10493         case PRIVATE:
10494         case PROCEDURE:
10495         case RAISE:
10496         case RANGE:
10497         case RAW:
10498         case REAL:
10499         case RECORD:
10500         case REF:
10501         case RELEASE:
10502         case RELIES_ON:
10503         case RENAME:
10504         case RESULT:
10505         case RETURN:
10506         case RETURNING:
10507         case REVERSE:
10508         case ROLLBACK:
10509         case ROW:
10510         case ROWS:
10511         case ROWID:
10512         case ROWNUM:
10513         case SAVE:
10514         case SAVEPOINT:
10515         case SECOND:
10516         case SELECT:
10517         case SELF:
10518         case SET:
10519         case SPACE:
10520         case SQL:
10521         case SQLCODE:
10522         case SQLERRM:
10523         case STATIC:
10524         case SUBTYPE:
10525         case SUBSTITUTABLE:
10526         case SUCCESSFUL:
10527         case SYSDATE:
10528         case SYS_REFCURSOR:
10529         case TEMPORARY:
10530         case TIME:
10531         case TIMESTAMP:
10532         case TIMEZONE_REGION:
10533         case TIMEZONE_ABBR:
10534         case TIMEZONE_MINUTE:
10535         case TIMEZONE_HOUR:
10536         case TRANSACTION:
10537         case TRUE:
10538         case TYPE:
10539         case UNDER:
10540         case USING:
10541         case WHILE:
10542         case YES:
10543         case SHOW:
10544         case A:
10545         case UPDATE:
10546         case DOUBLE:
10547         case DEC:
10548         case PRECISION:
10549         case INT:
10550         case NUMERIC:
10551         case NCHAR:
10552         case NVARCHAR2:
10553         case STRING:
10554         case UROWID:
10555         case VARRAY:
10556         case VARYING:
10557         case BFILE:
10558         case BLOB:
10559         case CLOB:
10560         case NCLOB:
10561         case YEAR:
10562         case LOCAL:
10563         case WITH:
10564         case ZONE:
10565         case CHARACTER:
10566         case AFTER:
10567         case BEFORE:
10568         case OLD:
10569         case PARENT:
10570         case CC_IF:
10571         case CC_ERROR:
10572         case ANALYZE:
10573         case ASSOCIATE:
10574         case AUDIT:
10575         case COMPOUND:
10576         case DATABASE:
10577         case CALL:
10578         case DDL:
10579         case DISASSOCIATE:
10580         case EACH:
10581         case FOLLOWS:
10582         case LOGOFF:
10583         case LOGON:
10584         case NESTED:
10585         case NOAUDIT:
10586         case SCHEMA:
10587         case SERVERERROR:
10588         case SHUTDOWN:
10589         case STARTUP:
10590         case STATEMENT:
10591         case STATISTICS:
10592         case SUSPEND:
10593         case TRUNCATE:
10594         case WRAPPED:
10595         case LIBRARY:
10596         case NAME:
10597         case STRUCT:
10598         case CONTEXT:
10599         case PARAMETERS:
10600         case LENGTH:
10601         case TDO:
10602         case MAXLEN:
10603         case CHARSETID:
10604         case CHARSETFORM:
10605         case ACCEPT:
10606         case ACCESSIBLE:
10607         case COPY:
10608         case DEFINE:
10609         case DISCONNECT:
10610         case HOST:
10611         case PRINT:
10612         case QUIT:
10613         case REMARK:
10614         case UNDEFINE:
10615         case VARIABLE:
10616         case WHENEVER:
10617         case ATTACH:
10618         case CAST:
10619         case TREAT:
10620         case TRIM:
10621         case LEFT:
10622         case RIGHT:
10623         case BOTH:
10624         case EMPTY:
10625         case MULTISET:
10626         case SUBMULTISET:
10627         case LEADING:
10628         case TRAILING:
10629         case CHAR_CS:
10630         case NCHAR_CS:
10631         case DBTIMEZONE:
10632         case SESSIONTIMEZONE:
10633         case AUTHENTICATED:
10634         case LINK:
10635         case SHARED:
10636         case DIRECTORY:
10637         case USER:
10638         case IDENTIFIER:
10639         case UNSIGNED_NUMERIC_LITERAL:
10640         case CHARACTER_LITERAL:
10641         case STRING_LITERAL:
10642         case QUOTED_LITERAL:
10643           ;
10644           break;
10645         default:
10646           jj_la1[128] = jj_gen;
10647           break label_26;
10648         }
10649       }
10650         jjtree.closeNodeScope(jjtn000, true);
10651         jjtc000 = false;
10652         {if (true) return jjtn000 ;}
10653     } catch (Throwable jjte000) {
10654           if (jjtc000) {
10655             jjtree.clearNodeScope(jjtn000);
10656             jjtc000 = false;
10657           } else {
10658             jjtree.popNode();
10659           }
10660           if (jjte000 instanceof RuntimeException) {
10661             {if (true) throw (RuntimeException)jjte000;}
10662           }
10663           if (jjte000 instanceof ParseException) {
10664             {if (true) throw (ParseException)jjte000;}
10665           }
10666           {if (true) throw (Error)jjte000;}
10667     } finally {
10668           if (jjtc000) {
10669             jjtree.closeNodeScope(jjtn000, true);
10670           }
10671     }
10672     throw new Error("Missing return statement in function");
10673   }
10674 
10675   final public ASTElseClause ElseClause() throws ParseException {
10676  /*@bgen(jjtree) ElseClause */
10677   ASTElseClause jjtn000 = new ASTElseClause(this, JJTELSECLAUSE);
10678   boolean jjtc000 = true;
10679   jjtree.openNodeScope(jjtn000);
10680     try {
10681       jj_consume_token(ELSE);
10682       label_27:
10683       while (true) {
10684         Statement();
10685         switch (jj_nt.kind) {
10686         case 5:
10687         case 16:
10688         case 17:
10689         case 21:
10690         case REPLACE:
10691         case DEFINER:
10692         case CURRENT_USER:
10693         case LANGUAGE:
10694         case INLINE:
10695         case ADD:
10696         case AGGREGATE:
10697         case ARRAY:
10698         case AT:
10699         case ATTRIBUTE:
10700         case AUTHID:
10701         case BEGIN:
10702         case BODY:
10703         case BULK:
10704         case BYTE:
10705         case CASCADE:
10706         case CASE:
10707         case CLOSE:
10708         case COALESCE:
10709         case COLLECT:
10710         case COLUMN:
10711         case COMMENT:
10712         case COMMIT:
10713         case CONSTRUCTOR:
10714         case CONTINUE:
10715         case CONVERT:
10716         case CURRENT:
10717         case CURSOR:
10718         case DATA:
10719         case DATE:
10720         case DAY:
10721         case DECLARE:
10722         case DELETE:
10723         case DISABLE:
10724         case EDITIONABLE:
10725         case ELEMENT:
10726         case ENABLE:
10727         case ESCAPE:
10728         case EXCEPT:
10729         case EXCEPTIONS:
10730         case EXECUTE:
10731         case EXIT:
10732         case EXTERNAL:
10733         case EXTENDS:
10734         case EXTRACT:
10735         case FALSE:
10736         case FETCH:
10737         case FINAL:
10738         case FOR:
10739         case FORALL:
10740         case FORCE:
10741         case FUNCTION:
10742         case GLOBAL:
10743         case GOTO:
10744         case HASH:
10745         case HEAP:
10746         case HOUR:
10747         case IF:
10748         case IMMEDIATE:
10749         case INDICES:
10750         case INDEXTYPE:
10751         case INDICATOR:
10752         case INSERT:
10753         case INSTANTIABLE:
10754         case INTERVAL:
10755         case INVALIDATE:
10756         case ISOLATION:
10757         case JAVA:
10758         case LEVEL:
10759         case LIMIT:
10760         case LOCK:
10761         case LOOP:
10762         case MAP:
10763         case MAX:
10764         case MEMBER:
10765         case MERGE:
10766         case MIN:
10767         case MINUTE:
10768         case MLSLABEL:
10769         case MODIFY:
10770         case MOD:
10771         case MONTH:
10772         case NATURAL:
10773         case NEW:
10774         case NEW_DOT:
10775         case NO:
10776         case NONEDITIONABLE:
10777         case NOT:
10778         case NULL:
10779         case NULLIF:
10780         case OBJECT:
10781         case OID:
10782         case OPAQUE:
10783         case OPEN:
10784         case OPERATOR:
10785         case ORGANIZATION:
10786         case OTHERS:
10787         case OVERRIDING:
10788         case PACKAGE:
10789         case PARTITION:
10790         case PIPE:
10791         case PRAGMA:
10792         case PRESERVE:
10793         case PRIVATE:
10794         case PROCEDURE:
10795         case RAISE:
10796         case RANGE:
10797         case RAW:
10798         case REAL:
10799         case RECORD:
10800         case REF:
10801         case RELEASE:
10802         case RELIES_ON:
10803         case RENAME:
10804         case RESULT:
10805         case RETURN:
10806         case RETURNING:
10807         case REVERSE:
10808         case ROLLBACK:
10809         case ROW:
10810         case ROWS:
10811         case ROWID:
10812         case ROWNUM:
10813         case SAVE:
10814         case SAVEPOINT:
10815         case SECOND:
10816         case SELECT:
10817         case SELF:
10818         case SET:
10819         case SPACE:
10820         case SQL:
10821         case SQLCODE:
10822         case SQLERRM:
10823         case STATIC:
10824         case SUBTYPE:
10825         case SUBSTITUTABLE:
10826         case SUCCESSFUL:
10827         case SYSDATE:
10828         case SYS_REFCURSOR:
10829         case TEMPORARY:
10830         case TIME:
10831         case TIMESTAMP:
10832         case TIMEZONE_REGION:
10833         case TIMEZONE_ABBR:
10834         case TIMEZONE_MINUTE:
10835         case TIMEZONE_HOUR:
10836         case TRANSACTION:
10837         case TRUE:
10838         case TYPE:
10839         case UNDER:
10840         case USING:
10841         case WHILE:
10842         case YES:
10843         case SHOW:
10844         case A:
10845         case UPDATE:
10846         case DOUBLE:
10847         case DEC:
10848         case PRECISION:
10849         case INT:
10850         case NUMERIC:
10851         case NCHAR:
10852         case NVARCHAR2:
10853         case STRING:
10854         case UROWID:
10855         case VARRAY:
10856         case VARYING:
10857         case BFILE:
10858         case BLOB:
10859         case CLOB:
10860         case NCLOB:
10861         case YEAR:
10862         case LOCAL:
10863         case WITH:
10864         case ZONE:
10865         case CHARACTER:
10866         case AFTER:
10867         case BEFORE:
10868         case OLD:
10869         case PARENT:
10870         case CC_IF:
10871         case CC_ERROR:
10872         case ANALYZE:
10873         case ASSOCIATE:
10874         case AUDIT:
10875         case COMPOUND:
10876         case DATABASE:
10877         case CALL:
10878         case DDL:
10879         case DISASSOCIATE:
10880         case EACH:
10881         case FOLLOWS:
10882         case LOGOFF:
10883         case LOGON:
10884         case NESTED:
10885         case NOAUDIT:
10886         case SCHEMA:
10887         case SERVERERROR:
10888         case SHUTDOWN:
10889         case STARTUP:
10890         case STATEMENT:
10891         case STATISTICS:
10892         case SUSPEND:
10893         case TRUNCATE:
10894         case WRAPPED:
10895         case LIBRARY:
10896         case NAME:
10897         case STRUCT:
10898         case CONTEXT:
10899         case PARAMETERS:
10900         case LENGTH:
10901         case TDO:
10902         case MAXLEN:
10903         case CHARSETID:
10904         case CHARSETFORM:
10905         case ACCEPT:
10906         case ACCESSIBLE:
10907         case COPY:
10908         case DEFINE:
10909         case DISCONNECT:
10910         case HOST:
10911         case PRINT:
10912         case QUIT:
10913         case REMARK:
10914         case UNDEFINE:
10915         case VARIABLE:
10916         case WHENEVER:
10917         case ATTACH:
10918         case CAST:
10919         case TREAT:
10920         case TRIM:
10921         case LEFT:
10922         case RIGHT:
10923         case BOTH:
10924         case EMPTY:
10925         case MULTISET:
10926         case SUBMULTISET:
10927         case LEADING:
10928         case TRAILING:
10929         case CHAR_CS:
10930         case NCHAR_CS:
10931         case DBTIMEZONE:
10932         case SESSIONTIMEZONE:
10933         case AUTHENTICATED:
10934         case LINK:
10935         case SHARED:
10936         case DIRECTORY:
10937         case USER:
10938         case IDENTIFIER:
10939         case UNSIGNED_NUMERIC_LITERAL:
10940         case CHARACTER_LITERAL:
10941         case STRING_LITERAL:
10942         case QUOTED_LITERAL:
10943           ;
10944           break;
10945         default:
10946           jj_la1[129] = jj_gen;
10947           break label_27;
10948         }
10949       }
10950         jjtree.closeNodeScope(jjtn000, true);
10951         jjtc000 = false;
10952         {if (true) return jjtn000 ;}
10953     } catch (Throwable jjte000) {
10954           if (jjtc000) {
10955             jjtree.clearNodeScope(jjtn000);
10956             jjtc000 = false;
10957           } else {
10958             jjtree.popNode();
10959           }
10960           if (jjte000 instanceof RuntimeException) {
10961             {if (true) throw (RuntimeException)jjte000;}
10962           }
10963           if (jjte000 instanceof ParseException) {
10964             {if (true) throw (ParseException)jjte000;}
10965           }
10966           {if (true) throw (Error)jjte000;}
10967     } finally {
10968           if (jjtc000) {
10969             jjtree.closeNodeScope(jjtn000, true);
10970           }
10971     }
10972     throw new Error("Missing return statement in function");
10973   }
10974 
10975   final public ASTElsifClause ElsifClause() throws ParseException {
10976  /*@bgen(jjtree) ElsifClause */
10977   ASTElsifClause jjtn000 = new ASTElsifClause(this, JJTELSIFCLAUSE);
10978   boolean jjtc000 = true;
10979   jjtree.openNodeScope(jjtn000);
10980     try {
10981       jj_consume_token(ELSIF);
10982       Expression();
10983       jj_consume_token(THEN);
10984       label_28:
10985       while (true) {
10986         Statement();
10987         switch (jj_nt.kind) {
10988         case 5:
10989         case 16:
10990         case 17:
10991         case 21:
10992         case REPLACE:
10993         case DEFINER:
10994         case CURRENT_USER:
10995         case LANGUAGE:
10996         case INLINE:
10997         case ADD:
10998         case AGGREGATE:
10999         case ARRAY:
11000         case AT:
11001         case ATTRIBUTE:
11002         case AUTHID:
11003         case BEGIN:
11004         case BODY:
11005         case BULK:
11006         case BYTE:
11007         case CASCADE:
11008         case CASE:
11009         case CLOSE:
11010         case COALESCE:
11011         case COLLECT:
11012         case COLUMN:
11013         case COMMENT:
11014         case COMMIT:
11015         case CONSTRUCTOR:
11016         case CONTINUE:
11017         case CONVERT:
11018         case CURRENT:
11019         case CURSOR:
11020         case DATA:
11021         case DATE:
11022         case DAY:
11023         case DECLARE:
11024         case DELETE:
11025         case DISABLE:
11026         case EDITIONABLE:
11027         case ELEMENT:
11028         case ENABLE:
11029         case ESCAPE:
11030         case EXCEPT:
11031         case EXCEPTIONS:
11032         case EXECUTE:
11033         case EXIT:
11034         case EXTERNAL:
11035         case EXTENDS:
11036         case EXTRACT:
11037         case FALSE:
11038         case FETCH:
11039         case FINAL:
11040         case FOR:
11041         case FORALL:
11042         case FORCE:
11043         case FUNCTION:
11044         case GLOBAL:
11045         case GOTO:
11046         case HASH:
11047         case HEAP:
11048         case HOUR:
11049         case IF:
11050         case IMMEDIATE:
11051         case INDICES:
11052         case INDEXTYPE:
11053         case INDICATOR:
11054         case INSERT:
11055         case INSTANTIABLE:
11056         case INTERVAL:
11057         case INVALIDATE:
11058         case ISOLATION:
11059         case JAVA:
11060         case LEVEL:
11061         case LIMIT:
11062         case LOCK:
11063         case LOOP:
11064         case MAP:
11065         case MAX:
11066         case MEMBER:
11067         case MERGE:
11068         case MIN:
11069         case MINUTE:
11070         case MLSLABEL:
11071         case MODIFY:
11072         case MOD:
11073         case MONTH:
11074         case NATURAL:
11075         case NEW:
11076         case NEW_DOT:
11077         case NO:
11078         case NONEDITIONABLE:
11079         case NOT:
11080         case NULL:
11081         case NULLIF:
11082         case OBJECT:
11083         case OID:
11084         case OPAQUE:
11085         case OPEN:
11086         case OPERATOR:
11087         case ORGANIZATION:
11088         case OTHERS:
11089         case OVERRIDING:
11090         case PACKAGE:
11091         case PARTITION:
11092         case PIPE:
11093         case PRAGMA:
11094         case PRESERVE:
11095         case PRIVATE:
11096         case PROCEDURE:
11097         case RAISE:
11098         case RANGE:
11099         case RAW:
11100         case REAL:
11101         case RECORD:
11102         case REF:
11103         case RELEASE:
11104         case RELIES_ON:
11105         case RENAME:
11106         case RESULT:
11107         case RETURN:
11108         case RETURNING:
11109         case REVERSE:
11110         case ROLLBACK:
11111         case ROW:
11112         case ROWS:
11113         case ROWID:
11114         case ROWNUM:
11115         case SAVE:
11116         case SAVEPOINT:
11117         case SECOND:
11118         case SELECT:
11119         case SELF:
11120         case SET:
11121         case SPACE:
11122         case SQL:
11123         case SQLCODE:
11124         case SQLERRM:
11125         case STATIC:
11126         case SUBTYPE:
11127         case SUBSTITUTABLE:
11128         case SUCCESSFUL:
11129         case SYSDATE:
11130         case SYS_REFCURSOR:
11131         case TEMPORARY:
11132         case TIME:
11133         case TIMESTAMP:
11134         case TIMEZONE_REGION:
11135         case TIMEZONE_ABBR:
11136         case TIMEZONE_MINUTE:
11137         case TIMEZONE_HOUR:
11138         case TRANSACTION:
11139         case TRUE:
11140         case TYPE:
11141         case UNDER:
11142         case USING:
11143         case WHILE:
11144         case YES:
11145         case SHOW:
11146         case A:
11147         case UPDATE:
11148         case DOUBLE:
11149         case DEC:
11150         case PRECISION:
11151         case INT:
11152         case NUMERIC:
11153         case NCHAR:
11154         case NVARCHAR2:
11155         case STRING:
11156         case UROWID:
11157         case VARRAY:
11158         case VARYING:
11159         case BFILE:
11160         case BLOB:
11161         case CLOB:
11162         case NCLOB:
11163         case YEAR:
11164         case LOCAL:
11165         case WITH:
11166         case ZONE:
11167         case CHARACTER:
11168         case AFTER:
11169         case BEFORE:
11170         case OLD:
11171         case PARENT:
11172         case CC_IF:
11173         case CC_ERROR:
11174         case ANALYZE:
11175         case ASSOCIATE:
11176         case AUDIT:
11177         case COMPOUND:
11178         case DATABASE:
11179         case CALL:
11180         case DDL:
11181         case DISASSOCIATE:
11182         case EACH:
11183         case FOLLOWS:
11184         case LOGOFF:
11185         case LOGON:
11186         case NESTED:
11187         case NOAUDIT:
11188         case SCHEMA:
11189         case SERVERERROR:
11190         case SHUTDOWN:
11191         case STARTUP:
11192         case STATEMENT:
11193         case STATISTICS:
11194         case SUSPEND:
11195         case TRUNCATE:
11196         case WRAPPED:
11197         case LIBRARY:
11198         case NAME:
11199         case STRUCT:
11200         case CONTEXT:
11201         case PARAMETERS:
11202         case LENGTH:
11203         case TDO:
11204         case MAXLEN:
11205         case CHARSETID:
11206         case CHARSETFORM:
11207         case ACCEPT:
11208         case ACCESSIBLE:
11209         case COPY:
11210         case DEFINE:
11211         case DISCONNECT:
11212         case HOST:
11213         case PRINT:
11214         case QUIT:
11215         case REMARK:
11216         case UNDEFINE:
11217         case VARIABLE:
11218         case WHENEVER:
11219         case ATTACH:
11220         case CAST:
11221         case TREAT:
11222         case TRIM:
11223         case LEFT:
11224         case RIGHT:
11225         case BOTH:
11226         case EMPTY:
11227         case MULTISET:
11228         case SUBMULTISET:
11229         case LEADING:
11230         case TRAILING:
11231         case CHAR_CS:
11232         case NCHAR_CS:
11233         case DBTIMEZONE:
11234         case SESSIONTIMEZONE:
11235         case AUTHENTICATED:
11236         case LINK:
11237         case SHARED:
11238         case DIRECTORY:
11239         case USER:
11240         case IDENTIFIER:
11241         case UNSIGNED_NUMERIC_LITERAL:
11242         case CHARACTER_LITERAL:
11243         case STRING_LITERAL:
11244         case QUOTED_LITERAL:
11245           ;
11246           break;
11247         default:
11248           jj_la1[130] = jj_gen;
11249           break label_28;
11250         }
11251       }
11252         jjtree.closeNodeScope(jjtn000, true);
11253         jjtc000 = false;
11254         {if (true) return jjtn000 ;}
11255     } catch (Throwable jjte000) {
11256         if (jjtc000) {
11257           jjtree.clearNodeScope(jjtn000);
11258           jjtc000 = false;
11259         } else {
11260           jjtree.popNode();
11261         }
11262         if (jjte000 instanceof RuntimeException) {
11263           {if (true) throw (RuntimeException)jjte000;}
11264         }
11265         if (jjte000 instanceof ParseException) {
11266           {if (true) throw (ParseException)jjte000;}
11267         }
11268         {if (true) throw (Error)jjte000;}
11269     } finally {
11270         if (jjtc000) {
11271           jjtree.closeNodeScope(jjtn000, true);
11272         }
11273     }
11274     throw new Error("Missing return statement in function");
11275   }
11276 
11277   final public ASTLoopStatement LoopStatement() throws ParseException {
11278  /*@bgen(jjtree) LoopStatement */
11279   ASTLoopStatement jjtn000 = new ASTLoopStatement(this, JJTLOOPSTATEMENT);
11280   boolean jjtc000 = true;
11281   jjtree.openNodeScope(jjtn000);
11282     try {
11283       jj_consume_token(LOOP);
11284       label_29:
11285       while (true) {
11286         Statement();
11287         switch (jj_nt.kind) {
11288         case 5:
11289         case 16:
11290         case 17:
11291         case 21:
11292         case REPLACE:
11293         case DEFINER:
11294         case CURRENT_USER:
11295         case LANGUAGE:
11296         case INLINE:
11297         case ADD:
11298         case AGGREGATE:
11299         case ARRAY:
11300         case AT:
11301         case ATTRIBUTE:
11302         case AUTHID:
11303         case BEGIN:
11304         case BODY:
11305         case BULK:
11306         case BYTE:
11307         case CASCADE:
11308         case CASE:
11309         case CLOSE:
11310         case COALESCE:
11311         case COLLECT:
11312         case COLUMN:
11313         case COMMENT:
11314         case COMMIT:
11315         case CONSTRUCTOR:
11316         case CONTINUE:
11317         case CONVERT:
11318         case CURRENT:
11319         case CURSOR:
11320         case DATA:
11321         case DATE:
11322         case DAY:
11323         case DECLARE:
11324         case DELETE:
11325         case DISABLE:
11326         case EDITIONABLE:
11327         case ELEMENT:
11328         case ENABLE:
11329         case ESCAPE:
11330         case EXCEPT:
11331         case EXCEPTIONS:
11332         case EXECUTE:
11333         case EXIT:
11334         case EXTERNAL:
11335         case EXTENDS:
11336         case EXTRACT:
11337         case FALSE:
11338         case FETCH:
11339         case FINAL:
11340         case FOR:
11341         case FORALL:
11342         case FORCE:
11343         case FUNCTION:
11344         case GLOBAL:
11345         case GOTO:
11346         case HASH:
11347         case HEAP:
11348         case HOUR:
11349         case IF:
11350         case IMMEDIATE:
11351         case INDICES:
11352         case INDEXTYPE:
11353         case INDICATOR:
11354         case INSERT:
11355         case INSTANTIABLE:
11356         case INTERVAL:
11357         case INVALIDATE:
11358         case ISOLATION:
11359         case JAVA:
11360         case LEVEL:
11361         case LIMIT:
11362         case LOCK:
11363         case LOOP:
11364         case MAP:
11365         case MAX:
11366         case MEMBER:
11367         case MERGE:
11368         case MIN:
11369         case MINUTE:
11370         case MLSLABEL:
11371         case MODIFY:
11372         case MOD:
11373         case MONTH:
11374         case NATURAL:
11375         case NEW:
11376         case NEW_DOT:
11377         case NO:
11378         case NONEDITIONABLE:
11379         case NOT:
11380         case NULL:
11381         case NULLIF:
11382         case OBJECT:
11383         case OID:
11384         case OPAQUE:
11385         case OPEN:
11386         case OPERATOR:
11387         case ORGANIZATION:
11388         case OTHERS:
11389         case OVERRIDING:
11390         case PACKAGE:
11391         case PARTITION:
11392         case PIPE:
11393         case PRAGMA:
11394         case PRESERVE:
11395         case PRIVATE:
11396         case PROCEDURE:
11397         case RAISE:
11398         case RANGE:
11399         case RAW:
11400         case REAL:
11401         case RECORD:
11402         case REF:
11403         case RELEASE:
11404         case RELIES_ON:
11405         case RENAME:
11406         case RESULT:
11407         case RETURN:
11408         case RETURNING:
11409         case REVERSE:
11410         case ROLLBACK:
11411         case ROW:
11412         case ROWS:
11413         case ROWID:
11414         case ROWNUM:
11415         case SAVE:
11416         case SAVEPOINT:
11417         case SECOND:
11418         case SELECT:
11419         case SELF:
11420         case SET:
11421         case SPACE:
11422         case SQL:
11423         case SQLCODE:
11424         case SQLERRM:
11425         case STATIC:
11426         case SUBTYPE:
11427         case SUBSTITUTABLE:
11428         case SUCCESSFUL:
11429         case SYSDATE:
11430         case SYS_REFCURSOR:
11431         case TEMPORARY:
11432         case TIME:
11433         case TIMESTAMP:
11434         case TIMEZONE_REGION:
11435         case TIMEZONE_ABBR:
11436         case TIMEZONE_MINUTE:
11437         case TIMEZONE_HOUR:
11438         case TRANSACTION:
11439         case TRUE:
11440         case TYPE:
11441         case UNDER:
11442         case USING:
11443         case WHILE:
11444         case YES:
11445         case SHOW:
11446         case A:
11447         case UPDATE:
11448         case DOUBLE:
11449         case DEC:
11450         case PRECISION:
11451         case INT:
11452         case NUMERIC:
11453         case NCHAR:
11454         case NVARCHAR2:
11455         case STRING:
11456         case UROWID:
11457         case VARRAY:
11458         case VARYING:
11459         case BFILE:
11460         case BLOB:
11461         case CLOB:
11462         case NCLOB:
11463         case YEAR:
11464         case LOCAL:
11465         case WITH:
11466         case ZONE:
11467         case CHARACTER:
11468         case AFTER:
11469         case BEFORE:
11470         case OLD:
11471         case PARENT:
11472         case CC_IF:
11473         case CC_ERROR:
11474         case ANALYZE:
11475         case ASSOCIATE:
11476         case AUDIT:
11477         case COMPOUND:
11478         case DATABASE:
11479         case CALL:
11480         case DDL:
11481         case DISASSOCIATE:
11482         case EACH:
11483         case FOLLOWS:
11484         case LOGOFF:
11485         case LOGON:
11486         case NESTED:
11487         case NOAUDIT:
11488         case SCHEMA:
11489         case SERVERERROR:
11490         case SHUTDOWN:
11491         case STARTUP:
11492         case STATEMENT:
11493         case STATISTICS:
11494         case SUSPEND:
11495         case TRUNCATE:
11496         case WRAPPED:
11497         case LIBRARY:
11498         case NAME:
11499         case STRUCT:
11500         case CONTEXT:
11501         case PARAMETERS:
11502         case LENGTH:
11503         case TDO:
11504         case MAXLEN:
11505         case CHARSETID:
11506         case CHARSETFORM:
11507         case ACCEPT:
11508         case ACCESSIBLE:
11509         case COPY:
11510         case DEFINE:
11511         case DISCONNECT:
11512         case HOST:
11513         case PRINT:
11514         case QUIT:
11515         case REMARK:
11516         case UNDEFINE:
11517         case VARIABLE:
11518         case WHENEVER:
11519         case ATTACH:
11520         case CAST:
11521         case TREAT:
11522         case TRIM:
11523         case LEFT:
11524         case RIGHT:
11525         case BOTH:
11526         case EMPTY:
11527         case MULTISET:
11528         case SUBMULTISET:
11529         case LEADING:
11530         case TRAILING:
11531         case CHAR_CS:
11532         case NCHAR_CS:
11533         case DBTIMEZONE:
11534         case SESSIONTIMEZONE:
11535         case AUTHENTICATED:
11536         case LINK:
11537         case SHARED:
11538         case DIRECTORY:
11539         case USER:
11540         case IDENTIFIER:
11541         case UNSIGNED_NUMERIC_LITERAL:
11542         case CHARACTER_LITERAL:
11543         case STRING_LITERAL:
11544         case QUOTED_LITERAL:
11545           ;
11546           break;
11547         default:
11548           jj_la1[131] = jj_gen;
11549           break label_29;
11550         }
11551       }
11552       jj_consume_token(END);
11553       jj_consume_token(LOOP);
11554       switch (jj_nt.kind) {
11555       case IDENTIFIER:
11556         jj_consume_token(IDENTIFIER);
11557         break;
11558       default:
11559         jj_la1[132] = jj_gen;
11560         ;
11561       }
11562         jjtree.closeNodeScope(jjtn000, true);
11563         jjtc000 = false;
11564         {if (true) return jjtn000 ;}
11565     } catch (Throwable jjte000) {
11566          if (jjtc000) {
11567            jjtree.clearNodeScope(jjtn000);
11568            jjtc000 = false;
11569          } else {
11570            jjtree.popNode();
11571          }
11572          if (jjte000 instanceof RuntimeException) {
11573            {if (true) throw (RuntimeException)jjte000;}
11574          }
11575          if (jjte000 instanceof ParseException) {
11576            {if (true) throw (ParseException)jjte000;}
11577          }
11578          {if (true) throw (Error)jjte000;}
11579     } finally {
11580          if (jjtc000) {
11581            jjtree.closeNodeScope(jjtn000, true);
11582          }
11583     }
11584     throw new Error("Missing return statement in function");
11585   }
11586 
11587 /** Scope rule: the loop index only exists within the Loop */
11588   final public ASTForStatement ForStatement() throws ParseException {
11589  /*@bgen(jjtree) ForStatement */
11590   ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
11591   boolean jjtc000 = true;
11592   jjtree.openNodeScope(jjtn000);
11593     try {
11594       jj_consume_token(FOR);
11595       ForIndex();
11596       jj_consume_token(IN);
11597       switch (jj_nt.kind) {
11598       case REVERSE:
11599         jj_consume_token(REVERSE);
11600         break;
11601       default:
11602         jj_la1[133] = jj_gen;
11603         ;
11604       }
11605       Expression();
11606       switch (jj_nt.kind) {
11607       case 12:
11608         jj_consume_token(12);
11609         Expression();
11610         break;
11611       default:
11612         jj_la1[134] = jj_gen;
11613         ;
11614       }
11615       jj_consume_token(LOOP);
11616       label_30:
11617       while (true) {
11618         Statement();
11619         switch (jj_nt.kind) {
11620         case 5:
11621         case 16:
11622         case 17:
11623         case 21:
11624         case REPLACE:
11625         case DEFINER:
11626         case CURRENT_USER:
11627         case LANGUAGE:
11628         case INLINE:
11629         case ADD:
11630         case AGGREGATE:
11631         case ARRAY:
11632         case AT:
11633         case ATTRIBUTE:
11634         case AUTHID:
11635         case BEGIN:
11636         case BODY:
11637         case BULK:
11638         case BYTE:
11639         case CASCADE:
11640         case CASE:
11641         case CLOSE:
11642         case COALESCE:
11643         case COLLECT:
11644         case COLUMN:
11645         case COMMENT:
11646         case COMMIT:
11647         case CONSTRUCTOR:
11648         case CONTINUE:
11649         case CONVERT:
11650         case CURRENT:
11651         case CURSOR:
11652         case DATA:
11653         case DATE:
11654         case DAY:
11655         case DECLARE:
11656         case DELETE:
11657         case DISABLE:
11658         case EDITIONABLE:
11659         case ELEMENT:
11660         case ENABLE:
11661         case ESCAPE:
11662         case EXCEPT:
11663         case EXCEPTIONS:
11664         case EXECUTE:
11665         case EXIT:
11666         case EXTERNAL:
11667         case EXTENDS:
11668         case EXTRACT:
11669         case FALSE:
11670         case FETCH:
11671         case FINAL:
11672         case FOR:
11673         case FORALL:
11674         case FORCE:
11675         case FUNCTION:
11676         case GLOBAL:
11677         case GOTO:
11678         case HASH:
11679         case HEAP:
11680         case HOUR:
11681         case IF:
11682         case IMMEDIATE:
11683         case INDICES:
11684         case INDEXTYPE:
11685         case INDICATOR:
11686         case INSERT:
11687         case INSTANTIABLE:
11688         case INTERVAL:
11689         case INVALIDATE:
11690         case ISOLATION:
11691         case JAVA:
11692         case LEVEL:
11693         case LIMIT:
11694         case LOCK:
11695         case LOOP:
11696         case MAP:
11697         case MAX:
11698         case MEMBER:
11699         case MERGE:
11700         case MIN:
11701         case MINUTE:
11702         case MLSLABEL:
11703         case MODIFY:
11704         case MOD:
11705         case MONTH:
11706         case NATURAL:
11707         case NEW:
11708         case NEW_DOT:
11709         case NO:
11710         case NONEDITIONABLE:
11711         case NOT:
11712         case NULL:
11713         case NULLIF:
11714         case OBJECT:
11715         case OID:
11716         case OPAQUE:
11717         case OPEN:
11718         case OPERATOR:
11719         case ORGANIZATION:
11720         case OTHERS:
11721         case OVERRIDING:
11722         case PACKAGE:
11723         case PARTITION:
11724         case PIPE:
11725         case PRAGMA:
11726         case PRESERVE:
11727         case PRIVATE:
11728         case PROCEDURE:
11729         case RAISE:
11730         case RANGE:
11731         case RAW:
11732         case REAL:
11733         case RECORD:
11734         case REF:
11735         case RELEASE:
11736         case RELIES_ON:
11737         case RENAME:
11738         case RESULT:
11739         case RETURN:
11740         case RETURNING:
11741         case REVERSE:
11742         case ROLLBACK:
11743         case ROW:
11744         case ROWS:
11745         case ROWID:
11746         case ROWNUM:
11747         case SAVE:
11748         case SAVEPOINT:
11749         case SECOND:
11750         case SELECT:
11751         case SELF:
11752         case SET:
11753         case SPACE:
11754         case SQL:
11755         case SQLCODE:
11756         case SQLERRM:
11757         case STATIC:
11758         case SUBTYPE:
11759         case SUBSTITUTABLE:
11760         case SUCCESSFUL:
11761         case SYSDATE:
11762         case SYS_REFCURSOR:
11763         case TEMPORARY:
11764         case TIME:
11765         case TIMESTAMP:
11766         case TIMEZONE_REGION:
11767         case TIMEZONE_ABBR:
11768         case TIMEZONE_MINUTE:
11769         case TIMEZONE_HOUR:
11770         case TRANSACTION:
11771         case TRUE:
11772         case TYPE:
11773         case UNDER:
11774         case USING:
11775         case WHILE:
11776         case YES:
11777         case SHOW:
11778         case A:
11779         case UPDATE:
11780         case DOUBLE:
11781         case DEC:
11782         case PRECISION:
11783         case INT:
11784         case NUMERIC:
11785         case NCHAR:
11786         case NVARCHAR2:
11787         case STRING:
11788         case UROWID:
11789         case VARRAY:
11790         case VARYING:
11791         case BFILE:
11792         case BLOB:
11793         case CLOB:
11794         case NCLOB:
11795         case YEAR:
11796         case LOCAL:
11797         case WITH:
11798         case ZONE:
11799         case CHARACTER:
11800         case AFTER:
11801         case BEFORE:
11802         case OLD:
11803         case PARENT:
11804         case CC_IF:
11805         case CC_ERROR:
11806         case ANALYZE:
11807         case ASSOCIATE:
11808         case AUDIT:
11809         case COMPOUND:
11810         case DATABASE:
11811         case CALL:
11812         case DDL:
11813         case DISASSOCIATE:
11814         case EACH:
11815         case FOLLOWS:
11816         case LOGOFF:
11817         case LOGON:
11818         case NESTED:
11819         case NOAUDIT:
11820         case SCHEMA:
11821         case SERVERERROR:
11822         case SHUTDOWN:
11823         case STARTUP:
11824         case STATEMENT:
11825         case STATISTICS:
11826         case SUSPEND:
11827         case TRUNCATE:
11828         case WRAPPED:
11829         case LIBRARY:
11830         case NAME:
11831         case STRUCT:
11832         case CONTEXT:
11833         case PARAMETERS:
11834         case LENGTH:
11835         case TDO:
11836         case MAXLEN:
11837         case CHARSETID:
11838         case CHARSETFORM:
11839         case ACCEPT:
11840         case ACCESSIBLE:
11841         case COPY:
11842         case DEFINE:
11843         case DISCONNECT:
11844         case HOST:
11845         case PRINT:
11846         case QUIT:
11847         case REMARK:
11848         case UNDEFINE:
11849         case VARIABLE:
11850         case WHENEVER:
11851         case ATTACH:
11852         case CAST:
11853         case TREAT:
11854         case TRIM:
11855         case LEFT:
11856         case RIGHT:
11857         case BOTH:
11858         case EMPTY:
11859         case MULTISET:
11860         case SUBMULTISET:
11861         case LEADING:
11862         case TRAILING:
11863         case CHAR_CS:
11864         case NCHAR_CS:
11865         case DBTIMEZONE:
11866         case SESSIONTIMEZONE:
11867         case AUTHENTICATED:
11868         case LINK:
11869         case SHARED:
11870         case DIRECTORY:
11871         case USER:
11872         case IDENTIFIER:
11873         case UNSIGNED_NUMERIC_LITERAL:
11874         case CHARACTER_LITERAL:
11875         case STRING_LITERAL:
11876         case QUOTED_LITERAL:
11877           ;
11878           break;
11879         default:
11880           jj_la1[135] = jj_gen;
11881           break label_30;
11882         }
11883       }
11884       jj_consume_token(END);
11885       jj_consume_token(LOOP);
11886       switch (jj_nt.kind) {
11887       case IDENTIFIER:
11888         jj_consume_token(IDENTIFIER);
11889         break;
11890       default:
11891         jj_la1[136] = jj_gen;
11892         ;
11893       }
11894         jjtree.closeNodeScope(jjtn000, true);
11895         jjtc000 = false;
11896         {if (true) return jjtn000 ;}
11897     } catch (Throwable jjte000) {
11898            if (jjtc000) {
11899              jjtree.clearNodeScope(jjtn000);
11900              jjtc000 = false;
11901            } else {
11902              jjtree.popNode();
11903            }
11904            if (jjte000 instanceof RuntimeException) {
11905              {if (true) throw (RuntimeException)jjte000;}
11906            }
11907            if (jjte000 instanceof ParseException) {
11908              {if (true) throw (ParseException)jjte000;}
11909            }
11910            {if (true) throw (Error)jjte000;}
11911     } finally {
11912            if (jjtc000) {
11913              jjtree.closeNodeScope(jjtn000, true);
11914            }
11915     }
11916     throw new Error("Missing return statement in function");
11917   }
11918 
11919   final public ASTWhileStatement WhileStatement() throws ParseException {
11920  /*@bgen(jjtree) WhileStatement */
11921   ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
11922   boolean jjtc000 = true;
11923   jjtree.openNodeScope(jjtn000);
11924     try {
11925       jj_consume_token(WHILE);
11926       Expression();
11927       jj_consume_token(LOOP);
11928       label_31:
11929       while (true) {
11930         Statement();
11931         switch (jj_nt.kind) {
11932         case 5:
11933         case 16:
11934         case 17:
11935         case 21:
11936         case REPLACE:
11937         case DEFINER:
11938         case CURRENT_USER:
11939         case LANGUAGE:
11940         case INLINE:
11941         case ADD:
11942         case AGGREGATE:
11943         case ARRAY:
11944         case AT:
11945         case ATTRIBUTE:
11946         case AUTHID:
11947         case BEGIN:
11948         case BODY:
11949         case BULK:
11950         case BYTE:
11951         case CASCADE:
11952         case CASE:
11953         case CLOSE:
11954         case COALESCE:
11955         case COLLECT:
11956         case COLUMN:
11957         case COMMENT:
11958         case COMMIT:
11959         case CONSTRUCTOR:
11960         case CONTINUE:
11961         case CONVERT:
11962         case CURRENT:
11963         case CURSOR:
11964         case DATA:
11965         case DATE:
11966         case DAY:
11967         case DECLARE:
11968         case DELETE:
11969         case DISABLE:
11970         case EDITIONABLE:
11971         case ELEMENT:
11972         case ENABLE:
11973         case ESCAPE:
11974         case EXCEPT:
11975         case EXCEPTIONS:
11976         case EXECUTE:
11977         case EXIT:
11978         case EXTERNAL:
11979         case EXTENDS:
11980         case EXTRACT:
11981         case FALSE:
11982         case FETCH:
11983         case FINAL:
11984         case FOR:
11985         case FORALL:
11986         case FORCE:
11987         case FUNCTION:
11988         case GLOBAL:
11989         case GOTO:
11990         case HASH:
11991         case HEAP:
11992         case HOUR:
11993         case IF:
11994         case IMMEDIATE:
11995         case INDICES:
11996         case INDEXTYPE:
11997         case INDICATOR:
11998         case INSERT:
11999         case INSTANTIABLE:
12000         case INTERVAL:
12001         case INVALIDATE:
12002         case ISOLATION:
12003         case JAVA:
12004         case LEVEL:
12005         case LIMIT:
12006         case LOCK:
12007         case LOOP:
12008         case MAP:
12009         case MAX:
12010         case MEMBER:
12011         case MERGE:
12012         case MIN:
12013         case MINUTE:
12014         case MLSLABEL:
12015         case MODIFY:
12016         case MOD:
12017         case MONTH:
12018         case NATURAL:
12019         case NEW:
12020         case NEW_DOT:
12021         case NO:
12022         case NONEDITIONABLE:
12023         case NOT:
12024         case NULL:
12025         case NULLIF:
12026         case OBJECT:
12027         case OID:
12028         case OPAQUE:
12029         case OPEN:
12030         case OPERATOR:
12031         case ORGANIZATION:
12032         case OTHERS:
12033         case OVERRIDING:
12034         case PACKAGE:
12035         case PARTITION:
12036         case PIPE:
12037         case PRAGMA:
12038         case PRESERVE:
12039         case PRIVATE:
12040         case PROCEDURE:
12041         case RAISE:
12042         case RANGE:
12043         case RAW:
12044         case REAL:
12045         case RECORD:
12046         case REF:
12047         case RELEASE:
12048         case RELIES_ON:
12049         case RENAME:
12050         case RESULT:
12051         case RETURN:
12052         case RETURNING:
12053         case REVERSE:
12054         case ROLLBACK:
12055         case ROW:
12056         case ROWS:
12057         case ROWID:
12058         case ROWNUM:
12059         case SAVE:
12060         case SAVEPOINT:
12061         case SECOND:
12062         case SELECT:
12063         case SELF:
12064         case SET:
12065         case SPACE:
12066         case SQL:
12067         case SQLCODE:
12068         case SQLERRM:
12069         case STATIC:
12070         case SUBTYPE:
12071         case SUBSTITUTABLE:
12072         case SUCCESSFUL:
12073         case SYSDATE:
12074         case SYS_REFCURSOR:
12075         case TEMPORARY:
12076         case TIME:
12077         case TIMESTAMP:
12078         case TIMEZONE_REGION:
12079         case TIMEZONE_ABBR:
12080         case TIMEZONE_MINUTE:
12081         case TIMEZONE_HOUR:
12082         case TRANSACTION:
12083         case TRUE:
12084         case TYPE:
12085         case UNDER:
12086         case USING:
12087         case WHILE:
12088         case YES:
12089         case SHOW:
12090         case A:
12091         case UPDATE:
12092         case DOUBLE:
12093         case DEC:
12094         case PRECISION:
12095         case INT:
12096         case NUMERIC:
12097         case NCHAR:
12098         case NVARCHAR2:
12099         case STRING:
12100         case UROWID:
12101         case VARRAY:
12102         case VARYING:
12103         case BFILE:
12104         case BLOB:
12105         case CLOB:
12106         case NCLOB:
12107         case YEAR:
12108         case LOCAL:
12109         case WITH:
12110         case ZONE:
12111         case CHARACTER:
12112         case AFTER:
12113         case BEFORE:
12114         case OLD:
12115         case PARENT:
12116         case CC_IF:
12117         case CC_ERROR:
12118         case ANALYZE:
12119         case ASSOCIATE:
12120         case AUDIT:
12121         case COMPOUND:
12122         case DATABASE:
12123         case CALL:
12124         case DDL:
12125         case DISASSOCIATE:
12126         case EACH:
12127         case FOLLOWS:
12128         case LOGOFF:
12129         case LOGON:
12130         case NESTED:
12131         case NOAUDIT:
12132         case SCHEMA:
12133         case SERVERERROR:
12134         case SHUTDOWN:
12135         case STARTUP:
12136         case STATEMENT:
12137         case STATISTICS:
12138         case SUSPEND:
12139         case TRUNCATE:
12140         case WRAPPED:
12141         case LIBRARY:
12142         case NAME:
12143         case STRUCT:
12144         case CONTEXT:
12145         case PARAMETERS:
12146         case LENGTH:
12147         case TDO:
12148         case MAXLEN:
12149         case CHARSETID:
12150         case CHARSETFORM:
12151         case ACCEPT:
12152         case ACCESSIBLE:
12153         case COPY:
12154         case DEFINE:
12155         case DISCONNECT:
12156         case HOST:
12157         case PRINT:
12158         case QUIT:
12159         case REMARK:
12160         case UNDEFINE:
12161         case VARIABLE:
12162         case WHENEVER:
12163         case ATTACH:
12164         case CAST:
12165         case TREAT:
12166         case TRIM:
12167         case LEFT:
12168         case RIGHT:
12169         case BOTH:
12170         case EMPTY:
12171         case MULTISET:
12172         case SUBMULTISET:
12173         case LEADING:
12174         case TRAILING:
12175         case CHAR_CS:
12176         case NCHAR_CS:
12177         case DBTIMEZONE:
12178         case SESSIONTIMEZONE:
12179         case AUTHENTICATED:
12180         case LINK:
12181         case SHARED:
12182         case DIRECTORY:
12183         case USER:
12184         case IDENTIFIER:
12185         case UNSIGNED_NUMERIC_LITERAL:
12186         case CHARACTER_LITERAL:
12187         case STRING_LITERAL:
12188         case QUOTED_LITERAL:
12189           ;
12190           break;
12191         default:
12192           jj_la1[137] = jj_gen;
12193           break label_31;
12194         }
12195       }
12196       jj_consume_token(END);
12197       jj_consume_token(LOOP);
12198       switch (jj_nt.kind) {
12199       case IDENTIFIER:
12200         jj_consume_token(IDENTIFIER);
12201         break;
12202       default:
12203         jj_la1[138] = jj_gen;
12204         ;
12205       }
12206         jjtree.closeNodeScope(jjtn000, true);
12207         jjtc000 = false;
12208         {if (true) return jjtn000 ;}
12209     } catch (Throwable jjte000) {
12210            if (jjtc000) {
12211              jjtree.clearNodeScope(jjtn000);
12212              jjtc000 = false;
12213            } else {
12214              jjtree.popNode();
12215            }
12216            if (jjte000 instanceof RuntimeException) {
12217              {if (true) throw (RuntimeException)jjte000;}
12218            }
12219            if (jjte000 instanceof ParseException) {
12220              {if (true) throw (ParseException)jjte000;}
12221            }
12222            {if (true) throw (Error)jjte000;}
12223     } finally {
12224            if (jjtc000) {
12225              jjtree.closeNodeScope(jjtn000, true);
12226            }
12227     }
12228     throw new Error("Missing return statement in function");
12229   }
12230 
12231   final public ASTIfStatement IfStatement() throws ParseException {
12232  /*@bgen(jjtree) IfStatement */
12233   ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
12234   boolean jjtc000 = true;
12235   jjtree.openNodeScope(jjtn000);
12236     try {
12237       jj_consume_token(IF);
12238       Expression();
12239       jj_consume_token(THEN);
12240       label_32:
12241       while (true) {
12242         Statement();
12243         switch (jj_nt.kind) {
12244         case 5:
12245         case 16:
12246         case 17:
12247         case 21:
12248         case REPLACE:
12249         case DEFINER:
12250         case CURRENT_USER:
12251         case LANGUAGE:
12252         case INLINE:
12253         case ADD:
12254         case AGGREGATE:
12255         case ARRAY:
12256         case AT:
12257         case ATTRIBUTE:
12258         case AUTHID:
12259         case BEGIN:
12260         case BODY:
12261         case BULK:
12262         case BYTE:
12263         case CASCADE:
12264         case CASE:
12265         case CLOSE:
12266         case COALESCE:
12267         case COLLECT:
12268         case COLUMN:
12269         case COMMENT:
12270         case COMMIT:
12271         case CONSTRUCTOR:
12272         case CONTINUE:
12273         case CONVERT:
12274         case CURRENT:
12275         case CURSOR:
12276         case DATA:
12277         case DATE:
12278         case DAY:
12279         case DECLARE:
12280         case DELETE:
12281         case DISABLE:
12282         case EDITIONABLE:
12283         case ELEMENT:
12284         case ENABLE:
12285         case ESCAPE:
12286         case EXCEPT:
12287         case EXCEPTIONS:
12288         case EXECUTE:
12289         case EXIT:
12290         case EXTERNAL:
12291         case EXTENDS:
12292         case EXTRACT:
12293         case FALSE:
12294         case FETCH:
12295         case FINAL:
12296         case FOR:
12297         case FORALL:
12298         case FORCE:
12299         case FUNCTION:
12300         case GLOBAL:
12301         case GOTO:
12302         case HASH:
12303         case HEAP:
12304         case HOUR:
12305         case IF:
12306         case IMMEDIATE:
12307         case INDICES:
12308         case INDEXTYPE:
12309         case INDICATOR:
12310         case INSERT:
12311         case INSTANTIABLE:
12312         case INTERVAL:
12313         case INVALIDATE:
12314         case ISOLATION:
12315         case JAVA:
12316         case LEVEL:
12317         case LIMIT:
12318         case LOCK:
12319         case LOOP:
12320         case MAP:
12321         case MAX:
12322         case MEMBER:
12323         case MERGE:
12324         case MIN:
12325         case MINUTE:
12326         case MLSLABEL:
12327         case MODIFY:
12328         case MOD:
12329         case MONTH:
12330         case NATURAL:
12331         case NEW:
12332         case NEW_DOT:
12333         case NO:
12334         case NONEDITIONABLE:
12335         case NOT:
12336         case NULL:
12337         case NULLIF:
12338         case OBJECT:
12339         case OID:
12340         case OPAQUE:
12341         case OPEN:
12342         case OPERATOR:
12343         case ORGANIZATION:
12344         case OTHERS:
12345         case OVERRIDING:
12346         case PACKAGE:
12347         case PARTITION:
12348         case PIPE:
12349         case PRAGMA:
12350         case PRESERVE:
12351         case PRIVATE:
12352         case PROCEDURE:
12353         case RAISE:
12354         case RANGE:
12355         case RAW:
12356         case REAL:
12357         case RECORD:
12358         case REF:
12359         case RELEASE:
12360         case RELIES_ON:
12361         case RENAME:
12362         case RESULT:
12363         case RETURN:
12364         case RETURNING:
12365         case REVERSE:
12366         case ROLLBACK:
12367         case ROW:
12368         case ROWS:
12369         case ROWID:
12370         case ROWNUM:
12371         case SAVE:
12372         case SAVEPOINT:
12373         case SECOND:
12374         case SELECT:
12375         case SELF:
12376         case SET:
12377         case SPACE:
12378         case SQL:
12379         case SQLCODE:
12380         case SQLERRM:
12381         case STATIC:
12382         case SUBTYPE:
12383         case SUBSTITUTABLE:
12384         case SUCCESSFUL:
12385         case SYSDATE:
12386         case SYS_REFCURSOR:
12387         case TEMPORARY:
12388         case TIME:
12389         case TIMESTAMP:
12390         case TIMEZONE_REGION:
12391         case TIMEZONE_ABBR:
12392         case TIMEZONE_MINUTE:
12393         case TIMEZONE_HOUR:
12394         case TRANSACTION:
12395         case TRUE:
12396         case TYPE:
12397         case UNDER:
12398         case USING:
12399         case WHILE:
12400         case YES:
12401         case SHOW:
12402         case A:
12403         case UPDATE:
12404         case DOUBLE:
12405         case DEC:
12406         case PRECISION:
12407         case INT:
12408         case NUMERIC:
12409         case NCHAR:
12410         case NVARCHAR2:
12411         case STRING:
12412         case UROWID:
12413         case VARRAY:
12414         case VARYING:
12415         case BFILE:
12416         case BLOB:
12417         case CLOB:
12418         case NCLOB:
12419         case YEAR:
12420         case LOCAL:
12421         case WITH:
12422         case ZONE:
12423         case CHARACTER:
12424         case AFTER:
12425         case BEFORE:
12426         case OLD:
12427         case PARENT:
12428         case CC_IF:
12429         case CC_ERROR:
12430         case ANALYZE:
12431         case ASSOCIATE:
12432         case AUDIT:
12433         case COMPOUND:
12434         case DATABASE:
12435         case CALL:
12436         case DDL:
12437         case DISASSOCIATE:
12438         case EACH:
12439         case FOLLOWS:
12440         case LOGOFF:
12441         case LOGON:
12442         case NESTED:
12443         case NOAUDIT:
12444         case SCHEMA:
12445         case SERVERERROR:
12446         case SHUTDOWN:
12447         case STARTUP:
12448         case STATEMENT:
12449         case STATISTICS:
12450         case SUSPEND:
12451         case TRUNCATE:
12452         case WRAPPED:
12453         case LIBRARY:
12454         case NAME:
12455         case STRUCT:
12456         case CONTEXT:
12457         case PARAMETERS:
12458         case LENGTH:
12459         case TDO:
12460         case MAXLEN:
12461         case CHARSETID:
12462         case CHARSETFORM:
12463         case ACCEPT:
12464         case ACCESSIBLE:
12465         case COPY:
12466         case DEFINE:
12467         case DISCONNECT:
12468         case HOST:
12469         case PRINT:
12470         case QUIT:
12471         case REMARK:
12472         case UNDEFINE:
12473         case VARIABLE:
12474         case WHENEVER:
12475         case ATTACH:
12476         case CAST:
12477         case TREAT:
12478         case TRIM:
12479         case LEFT:
12480         case RIGHT:
12481         case BOTH:
12482         case EMPTY:
12483         case MULTISET:
12484         case SUBMULTISET:
12485         case LEADING:
12486         case TRAILING:
12487         case CHAR_CS:
12488         case NCHAR_CS:
12489         case DBTIMEZONE:
12490         case SESSIONTIMEZONE:
12491         case AUTHENTICATED:
12492         case LINK:
12493         case SHARED:
12494         case DIRECTORY:
12495         case USER:
12496         case IDENTIFIER:
12497         case UNSIGNED_NUMERIC_LITERAL:
12498         case CHARACTER_LITERAL:
12499         case STRING_LITERAL:
12500         case QUOTED_LITERAL:
12501           ;
12502           break;
12503         default:
12504           jj_la1[139] = jj_gen;
12505           break label_32;
12506         }
12507       }
12508       label_33:
12509       while (true) {
12510         switch (jj_nt.kind) {
12511         case ELSIF:
12512           ;
12513           break;
12514         default:
12515           jj_la1[140] = jj_gen;
12516           break label_33;
12517         }
12518         ElsifClause();
12519                          jjtn000.setHasElse();
12520       }
12521       switch (jj_nt.kind) {
12522       case ELSE:
12523         ElseClause();
12524                         jjtn000.setHasElse();
12525         break;
12526       default:
12527         jj_la1[141] = jj_gen;
12528         ;
12529       }
12530       jj_consume_token(END);
12531       jj_consume_token(IF);
12532         jjtree.closeNodeScope(jjtn000, true);
12533         jjtc000 = false;
12534         {if (true) return jjtn000 ;}
12535     } catch (Throwable jjte000) {
12536           if (jjtc000) {
12537             jjtree.clearNodeScope(jjtn000);
12538             jjtc000 = false;
12539           } else {
12540             jjtree.popNode();
12541           }
12542           if (jjte000 instanceof RuntimeException) {
12543             {if (true) throw (RuntimeException)jjte000;}
12544           }
12545           if (jjte000 instanceof ParseException) {
12546             {if (true) throw (ParseException)jjte000;}
12547           }
12548           {if (true) throw (Error)jjte000;}
12549     } finally {
12550           if (jjtc000) {
12551             jjtree.closeNodeScope(jjtn000, true);
12552           }
12553     }
12554     throw new Error("Missing return statement in function");
12555   }
12556 
12557 /** Scope rule: the loop index only exists within the statement */
12558 /**
12559 ForIndex is declared implicitly, unlike most variables or constants.
12560 */
12561   final public ASTForIndex ForIndex() throws ParseException {
12562  /*@bgen(jjtree) ForIndex */
12563  ASTForIndex jjtn000 = new ASTForIndex(this, JJTFORINDEX);
12564  boolean jjtc000 = true;
12565  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
12566     try {
12567       simpleNode = ID();
12568    jjtree.closeNodeScope(jjtn000, true);
12569    jjtc000 = false;
12570    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
12571     } catch (Throwable jjte000) {
12572    if (jjtc000) {
12573      jjtree.clearNodeScope(jjtn000);
12574      jjtc000 = false;
12575    } else {
12576      jjtree.popNode();
12577    }
12578    if (jjte000 instanceof RuntimeException) {
12579      {if (true) throw (RuntimeException)jjte000;}
12580    }
12581    if (jjte000 instanceof ParseException) {
12582      {if (true) throw (ParseException)jjte000;}
12583    }
12584    {if (true) throw (Error)jjte000;}
12585     } finally {
12586    if (jjtc000) {
12587      jjtree.closeNodeScope(jjtn000, true);
12588    }
12589     }
12590     throw new Error("Missing return statement in function");
12591   }
12592 
12593 /**
12594 ForAllIndex is declared implicitly, unlike most variables or constants.
12595 */
12596   final public ASTForAllIndex ForAllIndex() throws ParseException {
12597  /*@bgen(jjtree) ForAllIndex */
12598  ASTForAllIndex jjtn000 = new ASTForAllIndex(this, JJTFORALLINDEX);
12599  boolean jjtc000 = true;
12600  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
12601     try {
12602       simpleNode = ID();
12603    jjtree.closeNodeScope(jjtn000, true);
12604    jjtc000 = false;
12605    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
12606     } catch (Throwable jjte000) {
12607    if (jjtc000) {
12608      jjtree.clearNodeScope(jjtn000);
12609      jjtc000 = false;
12610    } else {
12611      jjtree.popNode();
12612    }
12613    if (jjte000 instanceof RuntimeException) {
12614      {if (true) throw (RuntimeException)jjte000;}
12615    }
12616    if (jjte000 instanceof ParseException) {
12617      {if (true) throw (ParseException)jjte000;}
12618    }
12619    {if (true) throw (Error)jjte000;}
12620     } finally {
12621    if (jjtc000) {
12622      jjtree.closeNodeScope(jjtn000, true);
12623    }
12624     }
12625     throw new Error("Missing return statement in function");
12626   }
12627 
12628   final public ASTForAllStatement ForAllStatement() throws ParseException {
12629  /*@bgen(jjtree) ForAllStatement */
12630   ASTForAllStatement jjtn000 = new ASTForAllStatement(this, JJTFORALLSTATEMENT);
12631   boolean jjtc000 = true;
12632   jjtree.openNodeScope(jjtn000);
12633     try {
12634       jj_consume_token(FORALL);
12635       ForAllIndex();
12636       jj_consume_token(IN);
12637       switch (jj_nt.kind) {
12638       case INDICES:
12639       case VALUES:
12640         switch (jj_nt.kind) {
12641         case INDICES:
12642           jj_consume_token(INDICES);
12643           break;
12644         case VALUES:
12645           jj_consume_token(VALUES);
12646           break;
12647         default:
12648           jj_la1[142] = jj_gen;
12649           jj_consume_token(-1);
12650           throw new ParseException();
12651         }
12652         jj_consume_token(OF);
12653         Expression();
12654         break;
12655       case 5:
12656       case 16:
12657       case 17:
12658       case REPLACE:
12659       case DEFINER:
12660       case CURRENT_USER:
12661       case LANGUAGE:
12662       case INLINE:
12663       case ADD:
12664       case AGGREGATE:
12665       case ARRAY:
12666       case AT:
12667       case ATTRIBUTE:
12668       case AUTHID:
12669       case BODY:
12670       case BULK:
12671       case BYTE:
12672       case CASCADE:
12673       case CASE:
12674       case CLOSE:
12675       case COALESCE:
12676       case COLLECT:
12677       case COLUMN:
12678       case COMMENT:
12679       case COMMIT:
12680       case CONSTRUCTOR:
12681       case CONTINUE:
12682       case CONVERT:
12683       case CURRENT:
12684       case CURSOR:
12685       case DATA:
12686       case DATE:
12687       case DAY:
12688       case DISABLE:
12689       case EDITIONABLE:
12690       case ELEMENT:
12691       case ENABLE:
12692       case ESCAPE:
12693       case EXCEPT:
12694       case EXCEPTIONS:
12695       case EXIT:
12696       case EXTERNAL:
12697       case EXTENDS:
12698       case EXTRACT:
12699       case FALSE:
12700       case FINAL:
12701       case FORCE:
12702       case FUNCTION:
12703       case GLOBAL:
12704       case HASH:
12705       case HEAP:
12706       case HOUR:
12707       case IMMEDIATE:
12708       case INDEXTYPE:
12709       case INDICATOR:
12710       case INSTANTIABLE:
12711       case INTERVAL:
12712       case INVALIDATE:
12713       case ISOLATION:
12714       case JAVA:
12715       case LEVEL:
12716       case LIMIT:
12717       case LOOP:
12718       case MAP:
12719       case MAX:
12720       case MEMBER:
12721       case MERGE:
12722       case MIN:
12723       case MINUTE:
12724       case MLSLABEL:
12725       case MODIFY:
12726       case MOD:
12727       case MONTH:
12728       case NATURAL:
12729       case NEW:
12730       case NEW_DOT:
12731       case NO:
12732       case NONEDITIONABLE:
12733       case NOT:
12734       case NULL:
12735       case NULLIF:
12736       case OBJECT:
12737       case OID:
12738       case OPAQUE:
12739       case OPEN:
12740       case OPERATOR:
12741       case ORGANIZATION:
12742       case OTHERS:
12743       case OVERRIDING:
12744       case PACKAGE:
12745       case PARTITION:
12746       case PRESERVE:
12747       case PRIVATE:
12748       case PROCEDURE:
12749       case RANGE:
12750       case RAW:
12751       case REAL:
12752       case RECORD:
12753       case REF:
12754       case RELEASE:
12755       case RELIES_ON:
12756       case RENAME:
12757       case RESULT:
12758       case RETURN:
12759       case RETURNING:
12760       case REVERSE:
12761       case ROLLBACK:
12762       case ROW:
12763       case ROWS:
12764       case ROWID:
12765       case ROWNUM:
12766       case SAVE:
12767       case SAVEPOINT:
12768       case SECOND:
12769       case SELECT:
12770       case SELF:
12771       case SET:
12772       case SPACE:
12773       case SQL:
12774       case SQLCODE:
12775       case SQLERRM:
12776       case STATIC:
12777       case SUBTYPE:
12778       case SUBSTITUTABLE:
12779       case SUCCESSFUL:
12780       case SYSDATE:
12781       case SYS_REFCURSOR:
12782       case TEMPORARY:
12783       case TIME:
12784       case TIMESTAMP:
12785       case TIMEZONE_REGION:
12786       case TIMEZONE_ABBR:
12787       case TIMEZONE_MINUTE:
12788       case TIMEZONE_HOUR:
12789       case TRANSACTION:
12790       case TRUE:
12791       case TYPE:
12792       case UNDER:
12793       case USING:
12794       case YES:
12795       case SHOW:
12796       case A:
12797       case DOUBLE:
12798       case DEC:
12799       case PRECISION:
12800       case INT:
12801       case NUMERIC:
12802       case NCHAR:
12803       case NVARCHAR2:
12804       case STRING:
12805       case UROWID:
12806       case VARRAY:
12807       case VARYING:
12808       case BFILE:
12809       case BLOB:
12810       case CLOB:
12811       case NCLOB:
12812       case YEAR:
12813       case LOCAL:
12814       case WITH:
12815       case ZONE:
12816       case CHARACTER:
12817       case AFTER:
12818       case BEFORE:
12819       case OLD:
12820       case PARENT:
12821       case CC_IF:
12822       case ANALYZE:
12823       case ASSOCIATE:
12824       case AUDIT:
12825       case COMPOUND:
12826       case DATABASE:
12827       case CALL:
12828       case DDL:
12829       case DISASSOCIATE:
12830       case EACH:
12831       case FOLLOWS:
12832       case LOGOFF:
12833       case LOGON:
12834       case NESTED:
12835       case NOAUDIT:
12836       case SCHEMA:
12837       case SERVERERROR:
12838       case SHUTDOWN:
12839       case STARTUP:
12840       case STATEMENT:
12841       case STATISTICS:
12842       case SUSPEND:
12843       case TRUNCATE:
12844       case WRAPPED:
12845       case LIBRARY:
12846       case NAME:
12847       case STRUCT:
12848       case CONTEXT:
12849       case PARAMETERS:
12850       case LENGTH:
12851       case TDO:
12852       case MAXLEN:
12853       case CHARSETID:
12854       case CHARSETFORM:
12855       case ACCEPT:
12856       case ACCESSIBLE:
12857       case COPY:
12858       case DEFINE:
12859       case DISCONNECT:
12860       case HOST:
12861       case PRINT:
12862       case QUIT:
12863       case REMARK:
12864       case UNDEFINE:
12865       case VARIABLE:
12866       case WHENEVER:
12867       case ATTACH:
12868       case CAST:
12869       case TREAT:
12870       case TRIM:
12871       case LEFT:
12872       case RIGHT:
12873       case BOTH:
12874       case EMPTY:
12875       case MULTISET:
12876       case SUBMULTISET:
12877       case LEADING:
12878       case TRAILING:
12879       case CHAR_CS:
12880       case NCHAR_CS:
12881       case DBTIMEZONE:
12882       case SESSIONTIMEZONE:
12883       case AUTHENTICATED:
12884       case LINK:
12885       case SHARED:
12886       case DIRECTORY:
12887       case USER:
12888       case IDENTIFIER:
12889       case UNSIGNED_NUMERIC_LITERAL:
12890       case CHARACTER_LITERAL:
12891       case STRING_LITERAL:
12892       case QUOTED_LITERAL:
12893         Expression();
12894         switch (jj_nt.kind) {
12895         case 12:
12896           jj_consume_token(12);
12897           Expression();
12898           break;
12899         default:
12900           jj_la1[143] = jj_gen;
12901           ;
12902         }
12903         break;
12904       default:
12905         jj_la1[144] = jj_gen;
12906         jj_consume_token(-1);
12907         throw new ParseException();
12908       }
12909       switch (jj_nt.kind) {
12910       case SAVE:
12911         jj_consume_token(SAVE);
12912         jj_consume_token(EXCEPTIONS);
12913         break;
12914       default:
12915         jj_la1[145] = jj_gen;
12916         ;
12917       }
12918       SqlStatement(null,";");
12919         jjtree.closeNodeScope(jjtn000, true);
12920         jjtc000 = false;
12921         {if (true) return jjtn000 ;}
12922     } catch (Throwable jjte000) {
12923            if (jjtc000) {
12924              jjtree.clearNodeScope(jjtn000);
12925              jjtc000 = false;
12926            } else {
12927              jjtree.popNode();
12928            }
12929            if (jjte000 instanceof RuntimeException) {
12930              {if (true) throw (RuntimeException)jjte000;}
12931            }
12932            if (jjte000 instanceof ParseException) {
12933              {if (true) throw (ParseException)jjte000;}
12934            }
12935            {if (true) throw (Error)jjte000;}
12936     } finally {
12937            if (jjtc000) {
12938              jjtree.closeNodeScope(jjtn000, true);
12939            }
12940     }
12941     throw new Error("Missing return statement in function");
12942   }
12943 
12944   final public ASTGotoStatement GotoStatement() throws ParseException {
12945  /*@bgen(jjtree) GotoStatement */
12946  ASTGotoStatement jjtn000 = new ASTGotoStatement(this, JJTGOTOSTATEMENT);
12947  boolean jjtc000 = true;
12948  jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
12949     try {
12950       jj_consume_token(GOTO);
12951       label = QualifiedName();
12952         jjtree.closeNodeScope(jjtn000, true);
12953         jjtc000 = false;
12954         jjtn000.setImage(label.getImage()) ; {if (true) return jjtn000 ;}
12955     } catch (Throwable jjte000) {
12956           if (jjtc000) {
12957             jjtree.clearNodeScope(jjtn000);
12958             jjtc000 = false;
12959           } else {
12960             jjtree.popNode();
12961           }
12962           if (jjte000 instanceof RuntimeException) {
12963             {if (true) throw (RuntimeException)jjte000;}
12964           }
12965           if (jjte000 instanceof ParseException) {
12966             {if (true) throw (ParseException)jjte000;}
12967           }
12968           {if (true) throw (Error)jjte000;}
12969     } finally {
12970           if (jjtc000) {
12971             jjtree.closeNodeScope(jjtn000, true);
12972           }
12973     }
12974     throw new Error("Missing return statement in function");
12975   }
12976 
12977   final public ASTReturnStatement ReturnStatement() throws ParseException {
12978  /*@bgen(jjtree) ReturnStatement */
12979   ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
12980   boolean jjtc000 = true;
12981   jjtree.openNodeScope(jjtn000);
12982     try {
12983       jj_consume_token(RETURN);
12984       switch (jj_nt.kind) {
12985       case 5:
12986       case 16:
12987       case 17:
12988       case REPLACE:
12989       case DEFINER:
12990       case CURRENT_USER:
12991       case LANGUAGE:
12992       case INLINE:
12993       case ADD:
12994       case AGGREGATE:
12995       case ARRAY:
12996       case AT:
12997       case ATTRIBUTE:
12998       case AUTHID:
12999       case BODY:
13000       case BULK:
13001       case BYTE:
13002       case CASCADE:
13003       case CASE:
13004       case CLOSE:
13005       case COALESCE:
13006       case COLLECT:
13007       case COLUMN:
13008       case COMMENT:
13009       case COMMIT:
13010       case CONSTRUCTOR:
13011       case CONTINUE:
13012       case CONVERT:
13013       case CURRENT:
13014       case CURSOR:
13015       case DATA:
13016       case DATE:
13017       case DAY:
13018       case DISABLE:
13019       case EDITIONABLE:
13020       case ELEMENT:
13021       case ENABLE:
13022       case ESCAPE:
13023       case EXCEPT:
13024       case EXCEPTIONS:
13025       case EXIT:
13026       case EXTERNAL:
13027       case EXTENDS:
13028       case EXTRACT:
13029       case FALSE:
13030       case FINAL:
13031       case FORCE:
13032       case FUNCTION:
13033       case GLOBAL:
13034       case HASH:
13035       case HEAP:
13036       case HOUR:
13037       case IMMEDIATE:
13038       case INDICES:
13039       case INDEXTYPE:
13040       case INDICATOR:
13041       case INSTANTIABLE:
13042       case INTERVAL:
13043       case INVALIDATE:
13044       case ISOLATION:
13045       case JAVA:
13046       case LEVEL:
13047       case LIMIT:
13048       case LOOP:
13049       case MAP:
13050       case MAX:
13051       case MEMBER:
13052       case MERGE:
13053       case MIN:
13054       case MINUTE:
13055       case MLSLABEL:
13056       case MODIFY:
13057       case MOD:
13058       case MONTH:
13059       case NATURAL:
13060       case NEW:
13061       case NEW_DOT:
13062       case NO:
13063       case NONEDITIONABLE:
13064       case NOT:
13065       case NULL:
13066       case NULLIF:
13067       case OBJECT:
13068       case OID:
13069       case OPAQUE:
13070       case OPEN:
13071       case OPERATOR:
13072       case ORGANIZATION:
13073       case OTHERS:
13074       case OVERRIDING:
13075       case PACKAGE:
13076       case PARTITION:
13077       case PRESERVE:
13078       case PRIVATE:
13079       case PROCEDURE:
13080       case RANGE:
13081       case RAW:
13082       case REAL:
13083       case RECORD:
13084       case REF:
13085       case RELEASE:
13086       case RELIES_ON:
13087       case RENAME:
13088       case RESULT:
13089       case RETURN:
13090       case RETURNING:
13091       case REVERSE:
13092       case ROLLBACK:
13093       case ROW:
13094       case ROWS:
13095       case ROWID:
13096       case ROWNUM:
13097       case SAVE:
13098       case SAVEPOINT:
13099       case SECOND:
13100       case SELECT:
13101       case SELF:
13102       case SET:
13103       case SPACE:
13104       case SQL:
13105       case SQLCODE:
13106       case SQLERRM:
13107       case STATIC:
13108       case SUBTYPE:
13109       case SUBSTITUTABLE:
13110       case SUCCESSFUL:
13111       case SYSDATE:
13112       case SYS_REFCURSOR:
13113       case TEMPORARY:
13114       case TIME:
13115       case TIMESTAMP:
13116       case TIMEZONE_REGION:
13117       case TIMEZONE_ABBR:
13118       case TIMEZONE_MINUTE:
13119       case TIMEZONE_HOUR:
13120       case TRANSACTION:
13121       case TRUE:
13122       case TYPE:
13123       case UNDER:
13124       case USING:
13125       case YES:
13126       case SHOW:
13127       case A:
13128       case DOUBLE:
13129       case DEC:
13130       case PRECISION:
13131       case INT:
13132       case NUMERIC:
13133       case NCHAR:
13134       case NVARCHAR2:
13135       case STRING:
13136       case UROWID:
13137       case VARRAY:
13138       case VARYING:
13139       case BFILE:
13140       case BLOB:
13141       case CLOB:
13142       case NCLOB:
13143       case YEAR:
13144       case LOCAL:
13145       case WITH:
13146       case ZONE:
13147       case CHARACTER:
13148       case AFTER:
13149       case BEFORE:
13150       case OLD:
13151       case PARENT:
13152       case CC_IF:
13153       case ANALYZE:
13154       case ASSOCIATE:
13155       case AUDIT:
13156       case COMPOUND:
13157       case DATABASE:
13158       case CALL:
13159       case DDL:
13160       case DISASSOCIATE:
13161       case EACH:
13162       case FOLLOWS:
13163       case LOGOFF:
13164       case LOGON:
13165       case NESTED:
13166       case NOAUDIT:
13167       case SCHEMA:
13168       case SERVERERROR:
13169       case SHUTDOWN:
13170       case STARTUP:
13171       case STATEMENT:
13172       case STATISTICS:
13173       case SUSPEND:
13174       case TRUNCATE:
13175       case WRAPPED:
13176       case LIBRARY:
13177       case NAME:
13178       case STRUCT:
13179       case CONTEXT:
13180       case PARAMETERS:
13181       case LENGTH:
13182       case TDO:
13183       case MAXLEN:
13184       case CHARSETID:
13185       case CHARSETFORM:
13186       case ACCEPT:
13187       case ACCESSIBLE:
13188       case COPY:
13189       case DEFINE:
13190       case DISCONNECT:
13191       case HOST:
13192       case PRINT:
13193       case QUIT:
13194       case REMARK:
13195       case UNDEFINE:
13196       case VARIABLE:
13197       case WHENEVER:
13198       case ATTACH:
13199       case CAST:
13200       case TREAT:
13201       case TRIM:
13202       case LEFT:
13203       case RIGHT:
13204       case BOTH:
13205       case EMPTY:
13206       case MULTISET:
13207       case SUBMULTISET:
13208       case LEADING:
13209       case TRAILING:
13210       case CHAR_CS:
13211       case NCHAR_CS:
13212       case DBTIMEZONE:
13213       case SESSIONTIMEZONE:
13214       case AUTHENTICATED:
13215       case LINK:
13216       case SHARED:
13217       case DIRECTORY:
13218       case USER:
13219       case IDENTIFIER:
13220       case UNSIGNED_NUMERIC_LITERAL:
13221       case CHARACTER_LITERAL:
13222       case STRING_LITERAL:
13223       case QUOTED_LITERAL:
13224         Expression();
13225         break;
13226       default:
13227         jj_la1[146] = jj_gen;
13228         ;
13229       }
13230         jjtree.closeNodeScope(jjtn000, true);
13231         jjtc000 = false;
13232         {if (true) return jjtn000 ;}
13233     } catch (Throwable jjte000) {
13234           if (jjtc000) {
13235             jjtree.clearNodeScope(jjtn000);
13236             jjtc000 = false;
13237           } else {
13238             jjtree.popNode();
13239           }
13240           if (jjte000 instanceof RuntimeException) {
13241             {if (true) throw (RuntimeException)jjte000;}
13242           }
13243           if (jjte000 instanceof ParseException) {
13244             {if (true) throw (ParseException)jjte000;}
13245           }
13246           {if (true) throw (Error)jjte000;}
13247     } finally {
13248           if (jjtc000) {
13249             jjtree.closeNodeScope(jjtn000, true);
13250           }
13251     }
13252     throw new Error("Missing return statement in function");
13253   }
13254 
13255   final public ASTContinueStatement ContinueStatement() throws ParseException {
13256  /*@bgen(jjtree) ContinueStatement */
13257  ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
13258  boolean jjtc000 = true;
13259  jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13260     try {
13261       jj_consume_token(CONTINUE);
13262       switch (jj_nt.kind) {
13263       case REPLACE:
13264       case DEFINER:
13265       case CURRENT_USER:
13266       case LANGUAGE:
13267       case INLINE:
13268       case ADD:
13269       case AGGREGATE:
13270       case ARRAY:
13271       case AT:
13272       case ATTRIBUTE:
13273       case AUTHID:
13274       case BODY:
13275       case BULK:
13276       case BYTE:
13277       case CASCADE:
13278       case CLOSE:
13279       case COALESCE:
13280       case COLLECT:
13281       case COLUMN:
13282       case COMMENT:
13283       case COMMIT:
13284       case CONSTRUCTOR:
13285       case CONTINUE:
13286       case CONVERT:
13287       case CURRENT:
13288       case CURSOR:
13289       case DATA:
13290       case DAY:
13291       case DISABLE:
13292       case EDITIONABLE:
13293       case ELEMENT:
13294       case ENABLE:
13295       case ESCAPE:
13296       case EXCEPT:
13297       case EXCEPTIONS:
13298       case EXIT:
13299       case EXTERNAL:
13300       case EXTENDS:
13301       case EXTRACT:
13302       case FALSE:
13303       case FINAL:
13304       case FORCE:
13305       case FUNCTION:
13306       case GLOBAL:
13307       case HASH:
13308       case HEAP:
13309       case HOUR:
13310       case IMMEDIATE:
13311       case INDICES:
13312       case INDEXTYPE:
13313       case INDICATOR:
13314       case INSTANTIABLE:
13315       case INTERVAL:
13316       case INVALIDATE:
13317       case ISOLATION:
13318       case JAVA:
13319       case LEVEL:
13320       case LIMIT:
13321       case LOOP:
13322       case MAP:
13323       case MAX:
13324       case MEMBER:
13325       case MERGE:
13326       case MIN:
13327       case MINUTE:
13328       case MLSLABEL:
13329       case MODIFY:
13330       case MOD:
13331       case MONTH:
13332       case NATURAL:
13333       case NEW:
13334       case NO:
13335       case NONEDITIONABLE:
13336       case NULLIF:
13337       case OBJECT:
13338       case OID:
13339       case OPAQUE:
13340       case OPEN:
13341       case OPERATOR:
13342       case ORGANIZATION:
13343       case OTHERS:
13344       case OVERRIDING:
13345       case PACKAGE:
13346       case PARTITION:
13347       case PRESERVE:
13348       case PRIVATE:
13349       case PROCEDURE:
13350       case RANGE:
13351       case RAW:
13352       case REAL:
13353       case RECORD:
13354       case REF:
13355       case RELEASE:
13356       case RELIES_ON:
13357       case RENAME:
13358       case RESULT:
13359       case RETURN:
13360       case RETURNING:
13361       case REVERSE:
13362       case ROLLBACK:
13363       case ROW:
13364       case ROWS:
13365       case ROWID:
13366       case ROWNUM:
13367       case SAVE:
13368       case SAVEPOINT:
13369       case SECOND:
13370       case SELF:
13371       case SET:
13372       case SPACE:
13373       case SQL:
13374       case SQLCODE:
13375       case SQLERRM:
13376       case STATIC:
13377       case SUBTYPE:
13378       case SUBSTITUTABLE:
13379       case SUCCESSFUL:
13380       case SYSDATE:
13381       case SYS_REFCURSOR:
13382       case TEMPORARY:
13383       case TIME:
13384       case TIMESTAMP:
13385       case TIMEZONE_REGION:
13386       case TIMEZONE_ABBR:
13387       case TIMEZONE_MINUTE:
13388       case TIMEZONE_HOUR:
13389       case TRANSACTION:
13390       case TRUE:
13391       case TYPE:
13392       case UNDER:
13393       case USING:
13394       case YES:
13395       case SHOW:
13396       case A:
13397       case DOUBLE:
13398       case DEC:
13399       case PRECISION:
13400       case INT:
13401       case NUMERIC:
13402       case NCHAR:
13403       case NVARCHAR2:
13404       case STRING:
13405       case UROWID:
13406       case VARRAY:
13407       case VARYING:
13408       case BFILE:
13409       case BLOB:
13410       case CLOB:
13411       case NCLOB:
13412       case YEAR:
13413       case LOCAL:
13414       case ZONE:
13415       case CHARACTER:
13416       case AFTER:
13417       case BEFORE:
13418       case OLD:
13419       case PARENT:
13420       case ANALYZE:
13421       case ASSOCIATE:
13422       case AUDIT:
13423       case COMPOUND:
13424       case DATABASE:
13425       case CALL:
13426       case DDL:
13427       case DISASSOCIATE:
13428       case EACH:
13429       case FOLLOWS:
13430       case LOGOFF:
13431       case LOGON:
13432       case NESTED:
13433       case NOAUDIT:
13434       case SCHEMA:
13435       case SERVERERROR:
13436       case SHUTDOWN:
13437       case STARTUP:
13438       case STATEMENT:
13439       case STATISTICS:
13440       case SUSPEND:
13441       case TRUNCATE:
13442       case WRAPPED:
13443       case LIBRARY:
13444       case NAME:
13445       case STRUCT:
13446       case CONTEXT:
13447       case PARAMETERS:
13448       case LENGTH:
13449       case TDO:
13450       case MAXLEN:
13451       case CHARSETID:
13452       case CHARSETFORM:
13453       case ACCEPT:
13454       case ACCESSIBLE:
13455       case COPY:
13456       case DEFINE:
13457       case DISCONNECT:
13458       case HOST:
13459       case PRINT:
13460       case QUIT:
13461       case REMARK:
13462       case UNDEFINE:
13463       case VARIABLE:
13464       case WHENEVER:
13465       case ATTACH:
13466       case CAST:
13467       case TREAT:
13468       case TRIM:
13469       case LEFT:
13470       case RIGHT:
13471       case BOTH:
13472       case EMPTY:
13473       case MULTISET:
13474       case SUBMULTISET:
13475       case LEADING:
13476       case TRAILING:
13477       case CHAR_CS:
13478       case NCHAR_CS:
13479       case DBTIMEZONE:
13480       case SESSIONTIMEZONE:
13481       case AUTHENTICATED:
13482       case LINK:
13483       case SHARED:
13484       case DIRECTORY:
13485       case USER:
13486       case IDENTIFIER:
13487       case QUOTED_LITERAL:
13488         label = UnqualifiedID();
13489         break;
13490       default:
13491         jj_la1[147] = jj_gen;
13492         ;
13493       }
13494       switch (jj_nt.kind) {
13495       case WHEN:
13496         jj_consume_token(WHEN);
13497         Expression();
13498         break;
13499       default:
13500         jj_la1[148] = jj_gen;
13501         ;
13502       }
13503         jjtree.closeNodeScope(jjtn000, true);
13504         jjtc000 = false;
13505         if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13506     } catch (Throwable jjte000) {
13507           if (jjtc000) {
13508             jjtree.clearNodeScope(jjtn000);
13509             jjtc000 = false;
13510           } else {
13511             jjtree.popNode();
13512           }
13513           if (jjte000 instanceof RuntimeException) {
13514             {if (true) throw (RuntimeException)jjte000;}
13515           }
13516           if (jjte000 instanceof ParseException) {
13517             {if (true) throw (ParseException)jjte000;}
13518           }
13519           {if (true) throw (Error)jjte000;}
13520     } finally {
13521           if (jjtc000) {
13522             jjtree.closeNodeScope(jjtn000, true);
13523           }
13524     }
13525     throw new Error("Missing return statement in function");
13526   }
13527 
13528   final public ASTExitStatement ExitStatement() throws ParseException {
13529  /*@bgen(jjtree) ExitStatement */
13530  ASTExitStatement jjtn000 = new ASTExitStatement(this, JJTEXITSTATEMENT);
13531  boolean jjtc000 = true;
13532  jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13533     try {
13534       jj_consume_token(EXIT);
13535       switch (jj_nt.kind) {
13536       case REPLACE:
13537       case DEFINER:
13538       case CURRENT_USER:
13539       case LANGUAGE:
13540       case INLINE:
13541       case ADD:
13542       case AGGREGATE:
13543       case ARRAY:
13544       case AT:
13545       case ATTRIBUTE:
13546       case AUTHID:
13547       case BODY:
13548       case BULK:
13549       case BYTE:
13550       case CASCADE:
13551       case CLOSE:
13552       case COALESCE:
13553       case COLLECT:
13554       case COLUMN:
13555       case COMMENT:
13556       case COMMIT:
13557       case CONSTRUCTOR:
13558       case CONTINUE:
13559       case CONVERT:
13560       case CURRENT:
13561       case CURSOR:
13562       case DATA:
13563       case DAY:
13564       case DISABLE:
13565       case EDITIONABLE:
13566       case ELEMENT:
13567       case ENABLE:
13568       case ESCAPE:
13569       case EXCEPT:
13570       case EXCEPTIONS:
13571       case EXIT:
13572       case EXTERNAL:
13573       case EXTENDS:
13574       case EXTRACT:
13575       case FALSE:
13576       case FINAL:
13577       case FORCE:
13578       case FUNCTION:
13579       case GLOBAL:
13580       case HASH:
13581       case HEAP:
13582       case HOUR:
13583       case IMMEDIATE:
13584       case INDICES:
13585       case INDEXTYPE:
13586       case INDICATOR:
13587       case INSTANTIABLE:
13588       case INTERVAL:
13589       case INVALIDATE:
13590       case ISOLATION:
13591       case JAVA:
13592       case LEVEL:
13593       case LIMIT:
13594       case LOOP:
13595       case MAP:
13596       case MAX:
13597       case MEMBER:
13598       case MERGE:
13599       case MIN:
13600       case MINUTE:
13601       case MLSLABEL:
13602       case MODIFY:
13603       case MOD:
13604       case MONTH:
13605       case NATURAL:
13606       case NEW:
13607       case NO:
13608       case NONEDITIONABLE:
13609       case NULLIF:
13610       case OBJECT:
13611       case OID:
13612       case OPAQUE:
13613       case OPEN:
13614       case OPERATOR:
13615       case ORGANIZATION:
13616       case OTHERS:
13617       case OVERRIDING:
13618       case PACKAGE:
13619       case PARTITION:
13620       case PRESERVE:
13621       case PRIVATE:
13622       case PROCEDURE:
13623       case RANGE:
13624       case RAW:
13625       case REAL:
13626       case RECORD:
13627       case REF:
13628       case RELEASE:
13629       case RELIES_ON:
13630       case RENAME:
13631       case RESULT:
13632       case RETURN:
13633       case RETURNING:
13634       case REVERSE:
13635       case ROLLBACK:
13636       case ROW:
13637       case ROWS:
13638       case ROWID:
13639       case ROWNUM:
13640       case SAVE:
13641       case SAVEPOINT:
13642       case SECOND:
13643       case SELF:
13644       case SET:
13645       case SPACE:
13646       case SQL:
13647       case SQLCODE:
13648       case SQLERRM:
13649       case STATIC:
13650       case SUBTYPE:
13651       case SUBSTITUTABLE:
13652       case SUCCESSFUL:
13653       case SYSDATE:
13654       case SYS_REFCURSOR:
13655       case TEMPORARY:
13656       case TIME:
13657       case TIMESTAMP:
13658       case TIMEZONE_REGION:
13659       case TIMEZONE_ABBR:
13660       case TIMEZONE_MINUTE:
13661       case TIMEZONE_HOUR:
13662       case TRANSACTION:
13663       case TRUE:
13664       case TYPE:
13665       case UNDER:
13666       case USING:
13667       case YES:
13668       case SHOW:
13669       case A:
13670       case DOUBLE:
13671       case DEC:
13672       case PRECISION:
13673       case INT:
13674       case NUMERIC:
13675       case NCHAR:
13676       case NVARCHAR2:
13677       case STRING:
13678       case UROWID:
13679       case VARRAY:
13680       case VARYING:
13681       case BFILE:
13682       case BLOB:
13683       case CLOB:
13684       case NCLOB:
13685       case YEAR:
13686       case LOCAL:
13687       case ZONE:
13688       case CHARACTER:
13689       case AFTER:
13690       case BEFORE:
13691       case OLD:
13692       case PARENT:
13693       case ANALYZE:
13694       case ASSOCIATE:
13695       case AUDIT:
13696       case COMPOUND:
13697       case DATABASE:
13698       case CALL:
13699       case DDL:
13700       case DISASSOCIATE:
13701       case EACH:
13702       case FOLLOWS:
13703       case LOGOFF:
13704       case LOGON:
13705       case NESTED:
13706       case NOAUDIT:
13707       case SCHEMA:
13708       case SERVERERROR:
13709       case SHUTDOWN:
13710       case STARTUP:
13711       case STATEMENT:
13712       case STATISTICS:
13713       case SUSPEND:
13714       case TRUNCATE:
13715       case WRAPPED:
13716       case LIBRARY:
13717       case NAME:
13718       case STRUCT:
13719       case CONTEXT:
13720       case PARAMETERS:
13721       case LENGTH:
13722       case TDO:
13723       case MAXLEN:
13724       case CHARSETID:
13725       case CHARSETFORM:
13726       case ACCEPT:
13727       case ACCESSIBLE:
13728       case COPY:
13729       case DEFINE:
13730       case DISCONNECT:
13731       case HOST:
13732       case PRINT:
13733       case QUIT:
13734       case REMARK:
13735       case UNDEFINE:
13736       case VARIABLE:
13737       case WHENEVER:
13738       case ATTACH:
13739       case CAST:
13740       case TREAT:
13741       case TRIM:
13742       case LEFT:
13743       case RIGHT:
13744       case BOTH:
13745       case EMPTY:
13746       case MULTISET:
13747       case SUBMULTISET:
13748       case LEADING:
13749       case TRAILING:
13750       case CHAR_CS:
13751       case NCHAR_CS:
13752       case DBTIMEZONE:
13753       case SESSIONTIMEZONE:
13754       case AUTHENTICATED:
13755       case LINK:
13756       case SHARED:
13757       case DIRECTORY:
13758       case USER:
13759       case IDENTIFIER:
13760       case QUOTED_LITERAL:
13761         label = UnqualifiedID();
13762         break;
13763       default:
13764         jj_la1[149] = jj_gen;
13765         ;
13766       }
13767       switch (jj_nt.kind) {
13768       case WHEN:
13769         jj_consume_token(WHEN);
13770         Expression();
13771         break;
13772       default:
13773         jj_la1[150] = jj_gen;
13774         ;
13775       }
13776         jjtree.closeNodeScope(jjtn000, true);
13777         jjtc000 = false;
13778         if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13779     } catch (Throwable jjte000) {
13780           if (jjtc000) {
13781             jjtree.clearNodeScope(jjtn000);
13782             jjtc000 = false;
13783           } else {
13784             jjtree.popNode();
13785           }
13786           if (jjte000 instanceof RuntimeException) {
13787             {if (true) throw (RuntimeException)jjte000;}
13788           }
13789           if (jjte000 instanceof ParseException) {
13790             {if (true) throw (ParseException)jjte000;}
13791           }
13792           {if (true) throw (Error)jjte000;}
13793     } finally {
13794           if (jjtc000) {
13795             jjtree.closeNodeScope(jjtn000, true);
13796           }
13797     }
13798     throw new Error("Missing return statement in function");
13799   }
13800 
13801   final public ASTRaiseStatement RaiseStatement() throws ParseException {
13802  /*@bgen(jjtree) RaiseStatement */
13803  ASTRaiseStatement jjtn000 = new ASTRaiseStatement(this, JJTRAISESTATEMENT);
13804  boolean jjtc000 = true;
13805  jjtree.openNodeScope(jjtn000);PLSQLNode exception = null ;
13806     try {
13807       jj_consume_token(RAISE);
13808       switch (jj_nt.kind) {
13809       case REPLACE:
13810       case DEFINER:
13811       case CURRENT_USER:
13812       case LANGUAGE:
13813       case INLINE:
13814       case ADD:
13815       case AGGREGATE:
13816       case ARRAY:
13817       case AT:
13818       case ATTRIBUTE:
13819       case AUTHID:
13820       case BODY:
13821       case BULK:
13822       case BYTE:
13823       case CASCADE:
13824       case CLOSE:
13825       case COALESCE:
13826       case COLLECT:
13827       case COLUMN:
13828       case COMMENT:
13829       case COMMIT:
13830       case CONSTRUCTOR:
13831       case CONTINUE:
13832       case CONVERT:
13833       case CURRENT:
13834       case CURSOR:
13835       case DATA:
13836       case DAY:
13837       case DISABLE:
13838       case EDITIONABLE:
13839       case ELEMENT:
13840       case ENABLE:
13841       case ESCAPE:
13842       case EXCEPT:
13843       case EXCEPTIONS:
13844       case EXIT:
13845       case EXTERNAL:
13846       case EXTENDS:
13847       case EXTRACT:
13848       case FALSE:
13849       case FINAL:
13850       case FORCE:
13851       case FUNCTION:
13852       case GLOBAL:
13853       case HASH:
13854       case HEAP:
13855       case HOUR:
13856       case IMMEDIATE:
13857       case INDICES:
13858       case INDEXTYPE:
13859       case INDICATOR:
13860       case INSTANTIABLE:
13861       case INTERVAL:
13862       case INVALIDATE:
13863       case ISOLATION:
13864       case JAVA:
13865       case LEVEL:
13866       case LIMIT:
13867       case LOOP:
13868       case MAP:
13869       case MAX:
13870       case MEMBER:
13871       case MERGE:
13872       case MIN:
13873       case MINUTE:
13874       case MLSLABEL:
13875       case MODIFY:
13876       case MOD:
13877       case MONTH:
13878       case NATURAL:
13879       case NEW:
13880       case NO:
13881       case NONEDITIONABLE:
13882       case NULLIF:
13883       case OBJECT:
13884       case OID:
13885       case OPAQUE:
13886       case OPEN:
13887       case OPERATOR:
13888       case ORGANIZATION:
13889       case OTHERS:
13890       case OVERRIDING:
13891       case PACKAGE:
13892       case PARTITION:
13893       case PRESERVE:
13894       case PRIVATE:
13895       case PROCEDURE:
13896       case RANGE:
13897       case RAW:
13898       case REAL:
13899       case RECORD:
13900       case REF:
13901       case RELEASE:
13902       case RELIES_ON:
13903       case RENAME:
13904       case RESULT:
13905       case RETURN:
13906       case RETURNING:
13907       case REVERSE:
13908       case ROLLBACK:
13909       case ROW:
13910       case ROWS:
13911       case ROWID:
13912       case ROWNUM:
13913       case SAVE:
13914       case SAVEPOINT:
13915       case SECOND:
13916       case SELF:
13917       case SET:
13918       case SPACE:
13919       case SQL:
13920       case SQLCODE:
13921       case SQLERRM:
13922       case STATIC:
13923       case SUBTYPE:
13924       case SUBSTITUTABLE:
13925       case SUCCESSFUL:
13926       case SYSDATE:
13927       case SYS_REFCURSOR:
13928       case TEMPORARY:
13929       case TIME:
13930       case TIMESTAMP:
13931       case TIMEZONE_REGION:
13932       case TIMEZONE_ABBR:
13933       case TIMEZONE_MINUTE:
13934       case TIMEZONE_HOUR:
13935       case TRANSACTION:
13936       case TRUE:
13937       case TYPE:
13938       case UNDER:
13939       case USING:
13940       case YES:
13941       case SHOW:
13942       case A:
13943       case DOUBLE:
13944       case DEC:
13945       case PRECISION:
13946       case INT:
13947       case NUMERIC:
13948       case NCHAR:
13949       case NVARCHAR2:
13950       case STRING:
13951       case UROWID:
13952       case VARRAY:
13953       case VARYING:
13954       case BFILE:
13955       case BLOB:
13956       case CLOB:
13957       case NCLOB:
13958       case YEAR:
13959       case LOCAL:
13960       case ZONE:
13961       case CHARACTER:
13962       case AFTER:
13963       case BEFORE:
13964       case OLD:
13965       case PARENT:
13966       case ANALYZE:
13967       case ASSOCIATE:
13968       case AUDIT:
13969       case COMPOUND:
13970       case DATABASE:
13971       case CALL:
13972       case DDL:
13973       case DISASSOCIATE:
13974       case EACH:
13975       case FOLLOWS:
13976       case LOGOFF:
13977       case LOGON:
13978       case NESTED:
13979       case NOAUDIT:
13980       case SCHEMA:
13981       case SERVERERROR:
13982       case SHUTDOWN:
13983       case STARTUP:
13984       case STATEMENT:
13985       case STATISTICS:
13986       case SUSPEND:
13987       case TRUNCATE:
13988       case WRAPPED:
13989       case LIBRARY:
13990       case NAME:
13991       case STRUCT:
13992       case CONTEXT:
13993       case PARAMETERS:
13994       case LENGTH:
13995       case TDO:
13996       case MAXLEN:
13997       case CHARSETID:
13998       case CHARSETFORM:
13999       case ACCEPT:
14000       case ACCESSIBLE:
14001       case COPY:
14002       case DEFINE:
14003       case DISCONNECT:
14004       case HOST:
14005       case PRINT:
14006       case QUIT:
14007       case REMARK:
14008       case UNDEFINE:
14009       case VARIABLE:
14010       case WHENEVER:
14011       case ATTACH:
14012       case CAST:
14013       case TREAT:
14014       case TRIM:
14015       case LEFT:
14016       case RIGHT:
14017       case BOTH:
14018       case EMPTY:
14019       case MULTISET:
14020       case SUBMULTISET:
14021       case LEADING:
14022       case TRAILING:
14023       case CHAR_CS:
14024       case NCHAR_CS:
14025       case DBTIMEZONE:
14026       case SESSIONTIMEZONE:
14027       case AUTHENTICATED:
14028       case LINK:
14029       case SHARED:
14030       case DIRECTORY:
14031       case USER:
14032       case IDENTIFIER:
14033       case QUOTED_LITERAL:
14034         exception = QualifiedName();
14035         break;
14036       default:
14037         jj_la1[151] = jj_gen;
14038         ;
14039       }
14040         jjtree.closeNodeScope(jjtn000, true);
14041         jjtc000 = false;
14042         if (null != exception) { jjtn000.setImage(exception.getImage()) ; }  {if (true) return jjtn000 ;}
14043     } catch (Throwable jjte000) {
14044          if (jjtc000) {
14045            jjtree.clearNodeScope(jjtn000);
14046            jjtc000 = false;
14047          } else {
14048            jjtree.popNode();
14049          }
14050          if (jjte000 instanceof RuntimeException) {
14051            {if (true) throw (RuntimeException)jjte000;}
14052          }
14053          if (jjte000 instanceof ParseException) {
14054            {if (true) throw (ParseException)jjte000;}
14055          }
14056          {if (true) throw (Error)jjte000;}
14057     } finally {
14058          if (jjtc000) {
14059            jjtree.closeNodeScope(jjtn000, true);
14060          }
14061     }
14062     throw new Error("Missing return statement in function");
14063   }
14064 
14065   final public ASTCloseStatement CloseStatement() throws ParseException {
14066  /*@bgen(jjtree) CloseStatement */
14067  ASTCloseStatement jjtn000 = new ASTCloseStatement(this, JJTCLOSESTATEMENT);
14068  boolean jjtc000 = true;
14069  jjtree.openNodeScope(jjtn000);PLSQLNode cursor = null ;
14070     try {
14071       jj_consume_token(CLOSE);
14072       cursor = QualifiedName();
14073         jjtree.closeNodeScope(jjtn000, true);
14074         jjtc000 = false;
14075         jjtn000.setImage(cursor.getImage()) ; {if (true) return jjtn000 ;}
14076     } catch (Throwable jjte000) {
14077         if (jjtc000) {
14078           jjtree.clearNodeScope(jjtn000);
14079           jjtc000 = false;
14080         } else {
14081           jjtree.popNode();
14082         }
14083         if (jjte000 instanceof RuntimeException) {
14084           {if (true) throw (RuntimeException)jjte000;}
14085         }
14086         if (jjte000 instanceof ParseException) {
14087           {if (true) throw (ParseException)jjte000;}
14088         }
14089         {if (true) throw (Error)jjte000;}
14090     } finally {
14091         if (jjtc000) {
14092           jjtree.closeNodeScope(jjtn000, true);
14093         }
14094     }
14095     throw new Error("Missing return statement in function");
14096   }
14097 
14098   final public ASTOpenStatement OpenStatement() throws ParseException {
14099  /*@bgen(jjtree) OpenStatement */
14100   ASTOpenStatement jjtn000 = new ASTOpenStatement(this, JJTOPENSTATEMENT);
14101   boolean jjtc000 = true;
14102   jjtree.openNodeScope(jjtn000);
14103     try {
14104       jj_consume_token(OPEN);
14105       switch (jj_nt.kind) {
14106       case 5:
14107       case 16:
14108       case 17:
14109       case REPLACE:
14110       case DEFINER:
14111       case CURRENT_USER:
14112       case LANGUAGE:
14113       case INLINE:
14114       case ADD:
14115       case AGGREGATE:
14116       case ARRAY:
14117       case AT:
14118       case ATTRIBUTE:
14119       case AUTHID:
14120       case BODY:
14121       case BULK:
14122       case BYTE:
14123       case CASCADE:
14124       case CASE:
14125       case CLOSE:
14126       case COALESCE:
14127       case COLLECT:
14128       case COLUMN:
14129       case COMMENT:
14130       case COMMIT:
14131       case CONSTRUCTOR:
14132       case CONTINUE:
14133       case CONVERT:
14134       case CURRENT:
14135       case CURSOR:
14136       case DATA:
14137       case DATE:
14138       case DAY:
14139       case DISABLE:
14140       case EDITIONABLE:
14141       case ELEMENT:
14142       case ENABLE:
14143       case ESCAPE:
14144       case EXCEPT:
14145       case EXCEPTIONS:
14146       case EXIT:
14147       case EXTERNAL:
14148       case EXTENDS:
14149       case EXTRACT:
14150       case FALSE:
14151       case FINAL:
14152       case FORCE:
14153       case FUNCTION:
14154       case GLOBAL:
14155       case HASH:
14156       case HEAP:
14157       case HOUR:
14158       case IMMEDIATE:
14159       case INDICES:
14160       case INDEXTYPE:
14161       case INDICATOR:
14162       case INSTANTIABLE:
14163       case INTERVAL:
14164       case INVALIDATE:
14165       case ISOLATION:
14166       case JAVA:
14167       case LEVEL:
14168       case LIMIT:
14169       case LOOP:
14170       case MAP:
14171       case MAX:
14172       case MEMBER:
14173       case MERGE:
14174       case MIN:
14175       case MINUTE:
14176       case MLSLABEL:
14177       case MODIFY:
14178       case MOD:
14179       case MONTH:
14180       case NATURAL:
14181       case NEW:
14182       case NEW_DOT:
14183       case NO:
14184       case NONEDITIONABLE:
14185       case NOT:
14186       case NULL:
14187       case NULLIF:
14188       case OBJECT:
14189       case OID:
14190       case OPAQUE:
14191       case OPEN:
14192       case OPERATOR:
14193       case ORGANIZATION:
14194       case OTHERS:
14195       case OVERRIDING:
14196       case PACKAGE:
14197       case PARTITION:
14198       case PRESERVE:
14199       case PRIVATE:
14200       case PROCEDURE:
14201       case RANGE:
14202       case RAW:
14203       case REAL:
14204       case RECORD:
14205       case REF:
14206       case RELEASE:
14207       case RELIES_ON:
14208       case RENAME:
14209       case RESULT:
14210       case RETURN:
14211       case RETURNING:
14212       case REVERSE:
14213       case ROLLBACK:
14214       case ROW:
14215       case ROWS:
14216       case ROWID:
14217       case ROWNUM:
14218       case SAVE:
14219       case SAVEPOINT:
14220       case SECOND:
14221       case SELECT:
14222       case SELF:
14223       case SET:
14224       case SPACE:
14225       case SQL:
14226       case SQLCODE:
14227       case SQLERRM:
14228       case STATIC:
14229       case SUBTYPE:
14230       case SUBSTITUTABLE:
14231       case SUCCESSFUL:
14232       case SYSDATE:
14233       case SYS_REFCURSOR:
14234       case TEMPORARY:
14235       case TIME:
14236       case TIMESTAMP:
14237       case TIMEZONE_REGION:
14238       case TIMEZONE_ABBR:
14239       case TIMEZONE_MINUTE:
14240       case TIMEZONE_HOUR:
14241       case TRANSACTION:
14242       case TRUE:
14243       case TYPE:
14244       case UNDER:
14245       case USING:
14246       case YES:
14247       case SHOW:
14248       case A:
14249       case DOUBLE:
14250       case DEC:
14251       case PRECISION:
14252       case INT:
14253       case NUMERIC:
14254       case NCHAR:
14255       case NVARCHAR2:
14256       case STRING:
14257       case UROWID:
14258       case VARRAY:
14259       case VARYING:
14260       case BFILE:
14261       case BLOB:
14262       case CLOB:
14263       case NCLOB:
14264       case YEAR:
14265       case LOCAL:
14266       case WITH:
14267       case ZONE:
14268       case CHARACTER:
14269       case AFTER:
14270       case BEFORE:
14271       case OLD:
14272       case PARENT:
14273       case CC_IF:
14274       case ANALYZE:
14275       case ASSOCIATE:
14276       case AUDIT:
14277       case COMPOUND:
14278       case DATABASE:
14279       case CALL:
14280       case DDL:
14281       case DISASSOCIATE:
14282       case EACH:
14283       case FOLLOWS:
14284       case LOGOFF:
14285       case LOGON:
14286       case NESTED:
14287       case NOAUDIT:
14288       case SCHEMA:
14289       case SERVERERROR:
14290       case SHUTDOWN:
14291       case STARTUP:
14292       case STATEMENT:
14293       case STATISTICS:
14294       case SUSPEND:
14295       case TRUNCATE:
14296       case WRAPPED:
14297       case LIBRARY:
14298       case NAME:
14299       case STRUCT:
14300       case CONTEXT:
14301       case PARAMETERS:
14302       case LENGTH:
14303       case TDO:
14304       case MAXLEN:
14305       case CHARSETID:
14306       case CHARSETFORM:
14307       case ACCEPT:
14308       case ACCESSIBLE:
14309       case COPY:
14310       case DEFINE:
14311       case DISCONNECT:
14312       case HOST:
14313       case PRINT:
14314       case QUIT:
14315       case REMARK:
14316       case UNDEFINE:
14317       case VARIABLE:
14318       case WHENEVER:
14319       case ATTACH:
14320       case CAST:
14321       case TREAT:
14322       case TRIM:
14323       case LEFT:
14324       case RIGHT:
14325       case BOTH:
14326       case EMPTY:
14327       case MULTISET:
14328       case SUBMULTISET:
14329       case LEADING:
14330       case TRAILING:
14331       case CHAR_CS:
14332       case NCHAR_CS:
14333       case DBTIMEZONE:
14334       case SESSIONTIMEZONE:
14335       case AUTHENTICATED:
14336       case LINK:
14337       case SHARED:
14338       case DIRECTORY:
14339       case USER:
14340       case IDENTIFIER:
14341       case UNSIGNED_NUMERIC_LITERAL:
14342       case CHARACTER_LITERAL:
14343       case STRING_LITERAL:
14344       case QUOTED_LITERAL:
14345         Expression();
14346         break;
14347       default:
14348         jj_la1[152] = jj_gen;
14349         ;
14350       }
14351       switch (jj_nt.kind) {
14352       case FOR:
14353         jj_consume_token(FOR);
14354         Expression();
14355         switch (jj_nt.kind) {
14356         case USING:
14357           jj_consume_token(USING);
14358           switch (jj_nt.kind) {
14359           case IN:
14360           case IN_OUT:
14361           case OUT:
14362             switch (jj_nt.kind) {
14363             case IN:
14364               jj_consume_token(IN);
14365               break;
14366             case OUT:
14367               jj_consume_token(OUT);
14368               break;
14369             case IN_OUT:
14370               jj_consume_token(IN_OUT);
14371               break;
14372             default:
14373               jj_la1[153] = jj_gen;
14374               jj_consume_token(-1);
14375               throw new ParseException();
14376             }
14377             break;
14378           default:
14379             jj_la1[154] = jj_gen;
14380             ;
14381           }
14382           Expression();
14383           label_34:
14384           while (true) {
14385             switch (jj_nt.kind) {
14386             case 6:
14387               ;
14388               break;
14389             default:
14390               jj_la1[155] = jj_gen;
14391               break label_34;
14392             }
14393             jj_consume_token(6);
14394             switch (jj_nt.kind) {
14395             case IN:
14396             case IN_OUT:
14397             case OUT:
14398               switch (jj_nt.kind) {
14399               case IN:
14400                 jj_consume_token(IN);
14401                 break;
14402               case OUT:
14403                 jj_consume_token(OUT);
14404                 break;
14405               case IN_OUT:
14406                 jj_consume_token(IN_OUT);
14407                 break;
14408               default:
14409                 jj_la1[156] = jj_gen;
14410                 jj_consume_token(-1);
14411                 throw new ParseException();
14412               }
14413               break;
14414             default:
14415               jj_la1[157] = jj_gen;
14416               ;
14417             }
14418             Expression();
14419           }
14420           break;
14421         default:
14422           jj_la1[158] = jj_gen;
14423           ;
14424         }
14425         break;
14426       default:
14427         jj_la1[159] = jj_gen;
14428         ;
14429       }
14430         jjtree.closeNodeScope(jjtn000, true);
14431         jjtc000 = false;
14432         {if (true) return jjtn000 ;}
14433     } catch (Throwable jjte000) {
14434            if (jjtc000) {
14435              jjtree.clearNodeScope(jjtn000);
14436              jjtc000 = false;
14437            } else {
14438              jjtree.popNode();
14439            }
14440            if (jjte000 instanceof RuntimeException) {
14441              {if (true) throw (RuntimeException)jjte000;}
14442            }
14443            if (jjte000 instanceof ParseException) {
14444              {if (true) throw (ParseException)jjte000;}
14445            }
14446            {if (true) throw (Error)jjte000;}
14447     } finally {
14448            if (jjtc000) {
14449              jjtree.closeNodeScope(jjtn000, true);
14450            }
14451     }
14452     throw new Error("Missing return statement in function");
14453   }
14454 
14455   final public ASTFetchStatement FetchStatement() throws ParseException {
14456  /*@bgen(jjtree) FetchStatement */
14457   ASTFetchStatement jjtn000 = new ASTFetchStatement(this, JJTFETCHSTATEMENT);
14458   boolean jjtc000 = true;
14459   jjtree.openNodeScope(jjtn000);
14460     try {
14461       jj_consume_token(FETCH);
14462       QualifiedName();
14463       switch (jj_nt.kind) {
14464       case BULK:
14465         jj_consume_token(BULK);
14466         jj_consume_token(COLLECT);
14467         break;
14468       default:
14469         jj_la1[160] = jj_gen;
14470         ;
14471       }
14472       jj_consume_token(INTO);
14473       Expression();
14474       label_35:
14475       while (true) {
14476         switch (jj_nt.kind) {
14477         case 6:
14478           ;
14479           break;
14480         default:
14481           jj_la1[161] = jj_gen;
14482           break label_35;
14483         }
14484         jj_consume_token(6);
14485         Expression();
14486       }
14487       switch (jj_nt.kind) {
14488       case LIMIT:
14489         jj_consume_token(LIMIT);
14490         Expression();
14491         break;
14492       default:
14493         jj_la1[162] = jj_gen;
14494         ;
14495       }
14496         jjtree.closeNodeScope(jjtn000, true);
14497         jjtc000 = false;
14498         {if (true) return jjtn000 ;}
14499     } catch (Throwable jjte000) {
14500            if (jjtc000) {
14501              jjtree.clearNodeScope(jjtn000);
14502              jjtc000 = false;
14503            } else {
14504              jjtree.popNode();
14505            }
14506            if (jjte000 instanceof RuntimeException) {
14507              {if (true) throw (RuntimeException)jjte000;}
14508            }
14509            if (jjte000 instanceof ParseException) {
14510              {if (true) throw (ParseException)jjte000;}
14511            }
14512            {if (true) throw (Error)jjte000;}
14513     } finally {
14514            if (jjtc000) {
14515              jjtree.closeNodeScope(jjtn000, true);
14516            }
14517     }
14518     throw new Error("Missing return statement in function");
14519   }
14520 
14521   final public ASTEmbeddedSqlStatement EmbeddedSqlStatement() throws ParseException {
14522  /*@bgen(jjtree) EmbeddedSqlStatement */
14523   ASTEmbeddedSqlStatement jjtn000 = new ASTEmbeddedSqlStatement(this, JJTEMBEDDEDSQLSTATEMENT);
14524   boolean jjtc000 = true;
14525   jjtree.openNodeScope(jjtn000);
14526     try {
14527       jj_consume_token(EXECUTE);
14528       jj_consume_token(IMMEDIATE);
14529       Expression();
14530       switch (jj_nt.kind) {
14531       case INTO:
14532         jj_consume_token(INTO);
14533         Name();
14534         label_36:
14535         while (true) {
14536           switch (jj_nt.kind) {
14537           case 6:
14538             ;
14539             break;
14540           default:
14541             jj_la1[163] = jj_gen;
14542             break label_36;
14543           }
14544           jj_consume_token(6);
14545           Name();
14546         }
14547         break;
14548       default:
14549         jj_la1[164] = jj_gen;
14550         ;
14551       }
14552       switch (jj_nt.kind) {
14553       case USING:
14554         jj_consume_token(USING);
14555         switch (jj_nt.kind) {
14556         case IN:
14557         case OUT:
14558           switch (jj_nt.kind) {
14559           case IN:
14560             jj_consume_token(IN);
14561             switch (jj_nt.kind) {
14562             case OUT:
14563               jj_consume_token(OUT);
14564               break;
14565             default:
14566               jj_la1[165] = jj_gen;
14567               ;
14568             }
14569             break;
14570           case OUT:
14571             jj_consume_token(OUT);
14572             break;
14573           default:
14574             jj_la1[166] = jj_gen;
14575             jj_consume_token(-1);
14576             throw new ParseException();
14577           }
14578           break;
14579         default:
14580           jj_la1[167] = jj_gen;
14581           ;
14582         }
14583         Expression();
14584         label_37:
14585         while (true) {
14586           switch (jj_nt.kind) {
14587           case 6:
14588             ;
14589             break;
14590           default:
14591             jj_la1[168] = jj_gen;
14592             break label_37;
14593           }
14594           jj_consume_token(6);
14595           switch (jj_nt.kind) {
14596           case IN:
14597           case OUT:
14598             switch (jj_nt.kind) {
14599             case IN:
14600               jj_consume_token(IN);
14601               switch (jj_nt.kind) {
14602               case OUT:
14603                 jj_consume_token(OUT);
14604                 break;
14605               default:
14606                 jj_la1[169] = jj_gen;
14607                 ;
14608               }
14609               break;
14610             case OUT:
14611               jj_consume_token(OUT);
14612               break;
14613             default:
14614               jj_la1[170] = jj_gen;
14615               jj_consume_token(-1);
14616               throw new ParseException();
14617             }
14618             break;
14619           default:
14620             jj_la1[171] = jj_gen;
14621             ;
14622           }
14623           Expression();
14624         }
14625         break;
14626       default:
14627         jj_la1[172] = jj_gen;
14628         ;
14629       }
14630       switch (jj_nt.kind) {
14631       case RETURN:
14632       case RETURNING:
14633         switch (jj_nt.kind) {
14634         case RETURN:
14635           jj_consume_token(RETURN);
14636           break;
14637         case RETURNING:
14638           jj_consume_token(RETURNING);
14639           break;
14640         default:
14641           jj_la1[173] = jj_gen;
14642           jj_consume_token(-1);
14643           throw new ParseException();
14644         }
14645         jj_consume_token(INTO);
14646         Expression();
14647         label_38:
14648         while (true) {
14649           switch (jj_nt.kind) {
14650           case 6:
14651             ;
14652             break;
14653           default:
14654             jj_la1[174] = jj_gen;
14655             break label_38;
14656           }
14657           jj_consume_token(6);
14658           Expression();
14659         }
14660         break;
14661       default:
14662         jj_la1[175] = jj_gen;
14663         ;
14664       }
14665       jj_consume_token(4);
14666         jjtree.closeNodeScope(jjtn000, true);
14667         jjtc000 = false;
14668         {if (true) return jjtn000 ;}
14669     } catch (Throwable jjte000) {
14670      if (jjtc000) {
14671        jjtree.clearNodeScope(jjtn000);
14672        jjtc000 = false;
14673      } else {
14674        jjtree.popNode();
14675      }
14676      if (jjte000 instanceof RuntimeException) {
14677        {if (true) throw (RuntimeException)jjte000;}
14678      }
14679      if (jjte000 instanceof ParseException) {
14680        {if (true) throw (ParseException)jjte000;}
14681      }
14682      {if (true) throw (Error)jjte000;}
14683     } finally {
14684      if (jjtc000) {
14685        jjtree.closeNodeScope(jjtn000, true);
14686      }
14687     }
14688     throw new Error("Missing return statement in function");
14689   }
14690 
14691   final public ASTPipelineStatement PipelineStatement() throws ParseException {
14692  /*@bgen(jjtree) PipelineStatement */
14693   ASTPipelineStatement jjtn000 = new ASTPipelineStatement(this, JJTPIPELINESTATEMENT);
14694   boolean jjtc000 = true;
14695   jjtree.openNodeScope(jjtn000);
14696     try {
14697       jj_consume_token(PIPE);
14698       jj_consume_token(ROW);
14699       Expression();
14700         jjtree.closeNodeScope(jjtn000, true);
14701         jjtc000 = false;
14702         {if (true) return jjtn000 ;}
14703     } catch (Throwable jjte000) {
14704           if (jjtc000) {
14705             jjtree.clearNodeScope(jjtn000);
14706             jjtc000 = false;
14707           } else {
14708             jjtree.popNode();
14709           }
14710           if (jjte000 instanceof RuntimeException) {
14711             {if (true) throw (RuntimeException)jjte000;}
14712           }
14713           if (jjte000 instanceof ParseException) {
14714             {if (true) throw (ParseException)jjte000;}
14715           }
14716           {if (true) throw (Error)jjte000;}
14717     } finally {
14718           if (jjtc000) {
14719             jjtree.closeNodeScope(jjtn000, true);
14720           }
14721     }
14722     throw new Error("Missing return statement in function");
14723   }
14724 
14725   final public ASTConditionalCompilationStatement ConditionalCompilationStatement() throws ParseException {
14726  /*@bgen(jjtree) ConditionalCompilationStatement */
14727   ASTConditionalCompilationStatement jjtn000 = new ASTConditionalCompilationStatement(this, JJTCONDITIONALCOMPILATIONSTATEMENT);
14728   boolean jjtc000 = true;
14729   jjtree.openNodeScope(jjtn000);
14730     try {
14731       switch (jj_nt.kind) {
14732       case CC_IF:
14733         jj_consume_token(CC_IF);
14734         ConditionalOrExpression();
14735         jj_consume_token(CC_THEN);
14736         label_39:
14737         while (true) {
14738           switch (jj_nt.kind) {
14739           case 5:
14740           case 16:
14741           case 17:
14742           case 21:
14743           case REPLACE:
14744           case DEFINER:
14745           case CURRENT_USER:
14746           case LANGUAGE:
14747           case INLINE:
14748           case ADD:
14749           case AGGREGATE:
14750           case ARRAY:
14751           case AT:
14752           case ATTRIBUTE:
14753           case AUTHID:
14754           case BEGIN:
14755           case BODY:
14756           case BULK:
14757           case BYTE:
14758           case CASCADE:
14759           case CASE:
14760           case CLOSE:
14761           case COALESCE:
14762           case COLLECT:
14763           case COLUMN:
14764           case COMMENT:
14765           case COMMIT:
14766           case CONSTRUCTOR:
14767           case CONTINUE:
14768           case CONVERT:
14769           case CURRENT:
14770           case CURSOR:
14771           case DATA:
14772           case DATE:
14773           case DAY:
14774           case DECLARE:
14775           case DELETE:
14776           case DISABLE:
14777           case EDITIONABLE:
14778           case ELEMENT:
14779           case ENABLE:
14780           case ESCAPE:
14781           case EXCEPT:
14782           case EXCEPTIONS:
14783           case EXECUTE:
14784           case EXIT:
14785           case EXTERNAL:
14786           case EXTENDS:
14787           case EXTRACT:
14788           case FALSE:
14789           case FETCH:
14790           case FINAL:
14791           case FOR:
14792           case FORALL:
14793           case FORCE:
14794           case FUNCTION:
14795           case GLOBAL:
14796           case GOTO:
14797           case HASH:
14798           case HEAP:
14799           case HOUR:
14800           case IF:
14801           case IMMEDIATE:
14802           case INDICES:
14803           case INDEXTYPE:
14804           case INDICATOR:
14805           case INSERT:
14806           case INSTANTIABLE:
14807           case INTERVAL:
14808           case INVALIDATE:
14809           case ISOLATION:
14810           case JAVA:
14811           case LEVEL:
14812           case LIMIT:
14813           case LOCK:
14814           case LOOP:
14815           case MAP:
14816           case MAX:
14817           case MEMBER:
14818           case MERGE:
14819           case MIN:
14820           case MINUTE:
14821           case MLSLABEL:
14822           case MODIFY:
14823           case MOD:
14824           case MONTH:
14825           case NATURAL:
14826           case NEW:
14827           case NEW_DOT:
14828           case NO:
14829           case NONEDITIONABLE:
14830           case NOT:
14831           case NULL:
14832           case NULLIF:
14833           case OBJECT:
14834           case OID:
14835           case OPAQUE:
14836           case OPEN:
14837           case OPERATOR:
14838           case ORGANIZATION:
14839           case OTHERS:
14840           case OVERRIDING:
14841           case PACKAGE:
14842           case PARTITION:
14843           case PIPE:
14844           case PRAGMA:
14845           case PRESERVE:
14846           case PRIVATE:
14847           case PROCEDURE:
14848           case RAISE:
14849           case RANGE:
14850           case RAW:
14851           case REAL:
14852           case RECORD:
14853           case REF:
14854           case RELEASE:
14855           case RELIES_ON:
14856           case RENAME:
14857           case RESULT:
14858           case RETURN:
14859           case RETURNING:
14860           case REVERSE:
14861           case ROLLBACK:
14862           case ROW:
14863           case ROWS:
14864           case ROWID:
14865           case ROWNUM:
14866           case SAVE:
14867           case SAVEPOINT:
14868           case SECOND:
14869           case SELECT:
14870           case SELF:
14871           case SET:
14872           case SPACE:
14873           case SQL:
14874           case SQLCODE:
14875           case SQLERRM:
14876           case STATIC:
14877           case SUBTYPE:
14878           case SUBSTITUTABLE:
14879           case SUCCESSFUL:
14880           case SYSDATE:
14881           case SYS_REFCURSOR:
14882           case TEMPORARY:
14883           case TIME:
14884           case TIMESTAMP:
14885           case TIMEZONE_REGION:
14886           case TIMEZONE_ABBR:
14887           case TIMEZONE_MINUTE:
14888           case TIMEZONE_HOUR:
14889           case TRANSACTION:
14890           case TRUE:
14891           case TYPE:
14892           case UNDER:
14893           case USING:
14894           case WHILE:
14895           case YES:
14896           case SHOW:
14897           case A:
14898           case UPDATE:
14899           case DOUBLE:
14900           case DEC:
14901           case PRECISION:
14902           case INT:
14903           case NUMERIC:
14904           case NCHAR:
14905           case NVARCHAR2:
14906           case STRING:
14907           case UROWID:
14908           case VARRAY:
14909           case VARYING:
14910           case BFILE:
14911           case BLOB:
14912           case CLOB:
14913           case NCLOB:
14914           case YEAR:
14915           case LOCAL:
14916           case WITH:
14917           case ZONE:
14918           case CHARACTER:
14919           case AFTER:
14920           case BEFORE:
14921           case OLD:
14922           case PARENT:
14923           case CC_IF:
14924           case CC_ERROR:
14925           case ANALYZE:
14926           case ASSOCIATE:
14927           case AUDIT:
14928           case COMPOUND:
14929           case DATABASE:
14930           case CALL:
14931           case DDL:
14932           case DISASSOCIATE:
14933           case EACH:
14934           case FOLLOWS:
14935           case LOGOFF:
14936           case LOGON:
14937           case NESTED:
14938           case NOAUDIT:
14939           case SCHEMA:
14940           case SERVERERROR:
14941           case SHUTDOWN:
14942           case STARTUP:
14943           case STATEMENT:
14944           case STATISTICS:
14945           case SUSPEND:
14946           case TRUNCATE:
14947           case WRAPPED:
14948           case LIBRARY:
14949           case NAME:
14950           case STRUCT:
14951           case CONTEXT:
14952           case PARAMETERS:
14953           case LENGTH:
14954           case TDO:
14955           case MAXLEN:
14956           case CHARSETID:
14957           case CHARSETFORM:
14958           case ACCEPT:
14959           case ACCESSIBLE:
14960           case COPY:
14961           case DEFINE:
14962           case DISCONNECT:
14963           case HOST:
14964           case PRINT:
14965           case QUIT:
14966           case REMARK:
14967           case UNDEFINE:
14968           case VARIABLE:
14969           case WHENEVER:
14970           case ATTACH:
14971           case CAST:
14972           case TREAT:
14973           case TRIM:
14974           case LEFT:
14975           case RIGHT:
14976           case BOTH:
14977           case EMPTY:
14978           case MULTISET:
14979           case SUBMULTISET:
14980           case LEADING:
14981           case TRAILING:
14982           case CHAR_CS:
14983           case NCHAR_CS:
14984           case DBTIMEZONE:
14985           case SESSIONTIMEZONE:
14986           case AUTHENTICATED:
14987           case LINK:
14988           case SHARED:
14989           case DIRECTORY:
14990           case USER:
14991           case IDENTIFIER:
14992           case UNSIGNED_NUMERIC_LITERAL:
14993           case CHARACTER_LITERAL:
14994           case STRING_LITERAL:
14995           case QUOTED_LITERAL:
14996             ;
14997             break;
14998           default:
14999             jj_la1[176] = jj_gen;
15000             break label_39;
15001           }
15002           Statement();
15003         }
15004         label_40:
15005         while (true) {
15006           switch (jj_nt.kind) {
15007           case CC_ELSIF:
15008             ;
15009             break;
15010           default:
15011             jj_la1[177] = jj_gen;
15012             break label_40;
15013           }
15014           jj_consume_token(CC_ELSIF);
15015           ConditionalOrExpression();
15016           jj_consume_token(CC_THEN);
15017           label_41:
15018           while (true) {
15019             Statement();
15020             switch (jj_nt.kind) {
15021             case 5:
15022             case 16:
15023             case 17:
15024             case 21:
15025             case REPLACE:
15026             case DEFINER:
15027             case CURRENT_USER:
15028             case LANGUAGE:
15029             case INLINE:
15030             case ADD:
15031             case AGGREGATE:
15032             case ARRAY:
15033             case AT:
15034             case ATTRIBUTE:
15035             case AUTHID:
15036             case BEGIN:
15037             case BODY:
15038             case BULK:
15039             case BYTE:
15040             case CASCADE:
15041             case CASE:
15042             case CLOSE:
15043             case COALESCE:
15044             case COLLECT:
15045             case COLUMN:
15046             case COMMENT:
15047             case COMMIT:
15048             case CONSTRUCTOR:
15049             case CONTINUE:
15050             case CONVERT:
15051             case CURRENT:
15052             case CURSOR:
15053             case DATA:
15054             case DATE:
15055             case DAY:
15056             case DECLARE:
15057             case DELETE:
15058             case DISABLE:
15059             case EDITIONABLE:
15060             case ELEMENT:
15061             case ENABLE:
15062             case ESCAPE:
15063             case EXCEPT:
15064             case EXCEPTIONS:
15065             case EXECUTE:
15066             case EXIT:
15067             case EXTERNAL:
15068             case EXTENDS:
15069             case EXTRACT:
15070             case FALSE:
15071             case FETCH:
15072             case FINAL:
15073             case FOR:
15074             case FORALL:
15075             case FORCE:
15076             case FUNCTION:
15077             case GLOBAL:
15078             case GOTO:
15079             case HASH:
15080             case HEAP:
15081             case HOUR:
15082             case IF:
15083             case IMMEDIATE:
15084             case INDICES:
15085             case INDEXTYPE:
15086             case INDICATOR:
15087             case INSERT:
15088             case INSTANTIABLE:
15089             case INTERVAL:
15090             case INVALIDATE:
15091             case ISOLATION:
15092             case JAVA:
15093             case LEVEL:
15094             case LIMIT:
15095             case LOCK:
15096             case LOOP:
15097             case MAP:
15098             case MAX:
15099             case MEMBER:
15100             case MERGE:
15101             case MIN:
15102             case MINUTE:
15103             case MLSLABEL:
15104             case MODIFY:
15105             case MOD:
15106             case MONTH:
15107             case NATURAL:
15108             case NEW:
15109             case NEW_DOT:
15110             case NO:
15111             case NONEDITIONABLE:
15112             case NOT:
15113             case NULL:
15114             case NULLIF:
15115             case OBJECT:
15116             case OID:
15117             case OPAQUE:
15118             case OPEN:
15119             case OPERATOR:
15120             case ORGANIZATION:
15121             case OTHERS:
15122             case OVERRIDING:
15123             case PACKAGE:
15124             case PARTITION:
15125             case PIPE:
15126             case PRAGMA:
15127             case PRESERVE:
15128             case PRIVATE:
15129             case PROCEDURE:
15130             case RAISE:
15131             case RANGE:
15132             case RAW:
15133             case REAL:
15134             case RECORD:
15135             case REF:
15136             case RELEASE:
15137             case RELIES_ON:
15138             case RENAME:
15139             case RESULT:
15140             case RETURN:
15141             case RETURNING:
15142             case REVERSE:
15143             case ROLLBACK:
15144             case ROW:
15145             case ROWS:
15146             case ROWID:
15147             case ROWNUM:
15148             case SAVE:
15149             case SAVEPOINT:
15150             case SECOND:
15151             case SELECT:
15152             case SELF:
15153             case SET:
15154             case SPACE:
15155             case SQL:
15156             case SQLCODE:
15157             case SQLERRM:
15158             case STATIC:
15159             case SUBTYPE:
15160             case SUBSTITUTABLE:
15161             case SUCCESSFUL:
15162             case SYSDATE:
15163             case SYS_REFCURSOR:
15164             case TEMPORARY:
15165             case TIME:
15166             case TIMESTAMP:
15167             case TIMEZONE_REGION:
15168             case TIMEZONE_ABBR:
15169             case TIMEZONE_MINUTE:
15170             case TIMEZONE_HOUR:
15171             case TRANSACTION:
15172             case TRUE:
15173             case TYPE:
15174             case UNDER:
15175             case USING:
15176             case WHILE:
15177             case YES:
15178             case SHOW:
15179             case A:
15180             case UPDATE:
15181             case DOUBLE:
15182             case DEC:
15183             case PRECISION:
15184             case INT:
15185             case NUMERIC:
15186             case NCHAR:
15187             case NVARCHAR2:
15188             case STRING:
15189             case UROWID:
15190             case VARRAY:
15191             case VARYING:
15192             case BFILE:
15193             case BLOB:
15194             case CLOB:
15195             case NCLOB:
15196             case YEAR:
15197             case LOCAL:
15198             case WITH:
15199             case ZONE:
15200             case CHARACTER:
15201             case AFTER:
15202             case BEFORE:
15203             case OLD:
15204             case PARENT:
15205             case CC_IF:
15206             case CC_ERROR:
15207             case ANALYZE:
15208             case ASSOCIATE:
15209             case AUDIT:
15210             case COMPOUND:
15211             case DATABASE:
15212             case CALL:
15213             case DDL:
15214             case DISASSOCIATE:
15215             case EACH:
15216             case FOLLOWS:
15217             case LOGOFF:
15218             case LOGON:
15219             case NESTED:
15220             case NOAUDIT:
15221             case SCHEMA:
15222             case SERVERERROR:
15223             case SHUTDOWN:
15224             case STARTUP:
15225             case STATEMENT:
15226             case STATISTICS:
15227             case SUSPEND:
15228             case TRUNCATE:
15229             case WRAPPED:
15230             case LIBRARY:
15231             case NAME:
15232             case STRUCT:
15233             case CONTEXT:
15234             case PARAMETERS:
15235             case LENGTH:
15236             case TDO:
15237             case MAXLEN:
15238             case CHARSETID:
15239             case CHARSETFORM:
15240             case ACCEPT:
15241             case ACCESSIBLE:
15242             case COPY:
15243             case DEFINE:
15244             case DISCONNECT:
15245             case HOST:
15246             case PRINT:
15247             case QUIT:
15248             case REMARK:
15249             case UNDEFINE:
15250             case VARIABLE:
15251             case WHENEVER:
15252             case ATTACH:
15253             case CAST:
15254             case TREAT:
15255             case TRIM:
15256             case LEFT:
15257             case RIGHT:
15258             case BOTH:
15259             case EMPTY:
15260             case MULTISET:
15261             case SUBMULTISET:
15262             case LEADING:
15263             case TRAILING:
15264             case CHAR_CS:
15265             case NCHAR_CS:
15266             case DBTIMEZONE:
15267             case SESSIONTIMEZONE:
15268             case AUTHENTICATED:
15269             case LINK:
15270             case SHARED:
15271             case DIRECTORY:
15272             case USER:
15273             case IDENTIFIER:
15274             case UNSIGNED_NUMERIC_LITERAL:
15275             case CHARACTER_LITERAL:
15276             case STRING_LITERAL:
15277             case QUOTED_LITERAL:
15278               ;
15279               break;
15280             default:
15281               jj_la1[178] = jj_gen;
15282               break label_41;
15283             }
15284           }
15285         }
15286         label_42:
15287         while (true) {
15288           switch (jj_nt.kind) {
15289           case CC_ELSE:
15290             ;
15291             break;
15292           default:
15293             jj_la1[179] = jj_gen;
15294             break label_42;
15295           }
15296           jj_consume_token(CC_ELSE);
15297           label_43:
15298           while (true) {
15299             Statement();
15300             switch (jj_nt.kind) {
15301             case 5:
15302             case 16:
15303             case 17:
15304             case 21:
15305             case REPLACE:
15306             case DEFINER:
15307             case CURRENT_USER:
15308             case LANGUAGE:
15309             case INLINE:
15310             case ADD:
15311             case AGGREGATE:
15312             case ARRAY:
15313             case AT:
15314             case ATTRIBUTE:
15315             case AUTHID:
15316             case BEGIN:
15317             case BODY:
15318             case BULK:
15319             case BYTE:
15320             case CASCADE:
15321             case CASE:
15322             case CLOSE:
15323             case COALESCE:
15324             case COLLECT:
15325             case COLUMN:
15326             case COMMENT:
15327             case COMMIT:
15328             case CONSTRUCTOR:
15329             case CONTINUE:
15330             case CONVERT:
15331             case CURRENT:
15332             case CURSOR:
15333             case DATA:
15334             case DATE:
15335             case DAY:
15336             case DECLARE:
15337             case DELETE:
15338             case DISABLE:
15339             case EDITIONABLE:
15340             case ELEMENT:
15341             case ENABLE:
15342             case ESCAPE:
15343             case EXCEPT:
15344             case EXCEPTIONS:
15345             case EXECUTE:
15346             case EXIT:
15347             case EXTERNAL:
15348             case EXTENDS:
15349             case EXTRACT:
15350             case FALSE:
15351             case FETCH:
15352             case FINAL:
15353             case FOR:
15354             case FORALL:
15355             case FORCE:
15356             case FUNCTION:
15357             case GLOBAL:
15358             case GOTO:
15359             case HASH:
15360             case HEAP:
15361             case HOUR:
15362             case IF:
15363             case IMMEDIATE:
15364             case INDICES:
15365             case INDEXTYPE:
15366             case INDICATOR:
15367             case INSERT:
15368             case INSTANTIABLE:
15369             case INTERVAL:
15370             case INVALIDATE:
15371             case ISOLATION:
15372             case JAVA:
15373             case LEVEL:
15374             case LIMIT:
15375             case LOCK:
15376             case LOOP:
15377             case MAP:
15378             case MAX:
15379             case MEMBER:
15380             case MERGE:
15381             case MIN:
15382             case MINUTE:
15383             case MLSLABEL:
15384             case MODIFY:
15385             case MOD:
15386             case MONTH:
15387             case NATURAL:
15388             case NEW:
15389             case NEW_DOT:
15390             case NO:
15391             case NONEDITIONABLE:
15392             case NOT:
15393             case NULL:
15394             case NULLIF:
15395             case OBJECT:
15396             case OID:
15397             case OPAQUE:
15398             case OPEN:
15399             case OPERATOR:
15400             case ORGANIZATION:
15401             case OTHERS:
15402             case OVERRIDING:
15403             case PACKAGE:
15404             case PARTITION:
15405             case PIPE:
15406             case PRAGMA:
15407             case PRESERVE:
15408             case PRIVATE:
15409             case PROCEDURE:
15410             case RAISE:
15411             case RANGE:
15412             case RAW:
15413             case REAL:
15414             case RECORD:
15415             case REF:
15416             case RELEASE:
15417             case RELIES_ON:
15418             case RENAME:
15419             case RESULT:
15420             case RETURN:
15421             case RETURNING:
15422             case REVERSE:
15423             case ROLLBACK:
15424             case ROW:
15425             case ROWS:
15426             case ROWID:
15427             case ROWNUM:
15428             case SAVE:
15429             case SAVEPOINT:
15430             case SECOND:
15431             case SELECT:
15432             case SELF:
15433             case SET:
15434             case SPACE:
15435             case SQL:
15436             case SQLCODE:
15437             case SQLERRM:
15438             case STATIC:
15439             case SUBTYPE:
15440             case SUBSTITUTABLE:
15441             case SUCCESSFUL:
15442             case SYSDATE:
15443             case SYS_REFCURSOR:
15444             case TEMPORARY:
15445             case TIME:
15446             case TIMESTAMP:
15447             case TIMEZONE_REGION:
15448             case TIMEZONE_ABBR:
15449             case TIMEZONE_MINUTE:
15450             case TIMEZONE_HOUR:
15451             case TRANSACTION:
15452             case TRUE:
15453             case TYPE:
15454             case UNDER:
15455             case USING:
15456             case WHILE:
15457             case YES:
15458             case SHOW:
15459             case A:
15460             case UPDATE:
15461             case DOUBLE:
15462             case DEC:
15463             case PRECISION:
15464             case INT:
15465             case NUMERIC:
15466             case NCHAR:
15467             case NVARCHAR2:
15468             case STRING:
15469             case UROWID:
15470             case VARRAY:
15471             case VARYING:
15472             case BFILE:
15473             case BLOB:
15474             case CLOB:
15475             case NCLOB:
15476             case YEAR:
15477             case LOCAL:
15478             case WITH:
15479             case ZONE:
15480             case CHARACTER:
15481             case AFTER:
15482             case BEFORE:
15483             case OLD:
15484             case PARENT:
15485             case CC_IF:
15486             case CC_ERROR:
15487             case ANALYZE:
15488             case ASSOCIATE:
15489             case AUDIT:
15490             case COMPOUND:
15491             case DATABASE:
15492             case CALL:
15493             case DDL:
15494             case DISASSOCIATE:
15495             case EACH:
15496             case FOLLOWS:
15497             case LOGOFF:
15498             case LOGON:
15499             case NESTED:
15500             case NOAUDIT:
15501             case SCHEMA:
15502             case SERVERERROR:
15503             case SHUTDOWN:
15504             case STARTUP:
15505             case STATEMENT:
15506             case STATISTICS:
15507             case SUSPEND:
15508             case TRUNCATE:
15509             case WRAPPED:
15510             case LIBRARY:
15511             case NAME:
15512             case STRUCT:
15513             case CONTEXT:
15514             case PARAMETERS:
15515             case LENGTH:
15516             case TDO:
15517             case MAXLEN:
15518             case CHARSETID:
15519             case CHARSETFORM:
15520             case ACCEPT:
15521             case ACCESSIBLE:
15522             case COPY:
15523             case DEFINE:
15524             case DISCONNECT:
15525             case HOST:
15526             case PRINT:
15527             case QUIT:
15528             case REMARK:
15529             case UNDEFINE:
15530             case VARIABLE:
15531             case WHENEVER:
15532             case ATTACH:
15533             case CAST:
15534             case TREAT:
15535             case TRIM:
15536             case LEFT:
15537             case RIGHT:
15538             case BOTH:
15539             case EMPTY:
15540             case MULTISET:
15541             case SUBMULTISET:
15542             case LEADING:
15543             case TRAILING:
15544             case CHAR_CS:
15545             case NCHAR_CS:
15546             case DBTIMEZONE:
15547             case SESSIONTIMEZONE:
15548             case AUTHENTICATED:
15549             case LINK:
15550             case SHARED:
15551             case DIRECTORY:
15552             case USER:
15553             case IDENTIFIER:
15554             case UNSIGNED_NUMERIC_LITERAL:
15555             case CHARACTER_LITERAL:
15556             case STRING_LITERAL:
15557             case QUOTED_LITERAL:
15558               ;
15559               break;
15560             default:
15561               jj_la1[180] = jj_gen;
15562               break label_43;
15563             }
15564           }
15565         }
15566         jj_consume_token(CC_END);
15567         break;
15568       case CC_ERROR:
15569         jj_consume_token(CC_ERROR);
15570         Expression();
15571         jj_consume_token(CC_END);
15572         break;
15573       default:
15574         jj_la1[181] = jj_gen;
15575         jj_consume_token(-1);
15576         throw new ParseException();
15577       }
15578         jjtree.closeNodeScope(jjtn000, true);
15579         jjtc000 = false;
15580         {if (true) return jjtn000 ;}
15581     } catch (Throwable jjte000) {
15582           if (jjtc000) {
15583             jjtree.clearNodeScope(jjtn000);
15584             jjtc000 = false;
15585           } else {
15586             jjtree.popNode();
15587           }
15588           if (jjte000 instanceof RuntimeException) {
15589             {if (true) throw (RuntimeException)jjte000;}
15590           }
15591           if (jjte000 instanceof ParseException) {
15592             {if (true) throw (ParseException)jjte000;}
15593           }
15594           {if (true) throw (Error)jjte000;}
15595     } finally {
15596           if (jjtc000) {
15597             jjtree.closeNodeScope(jjtn000, true);
15598           }
15599     }
15600     throw new Error("Missing return statement in function");
15601   }
15602 
15603   final public ASTSubTypeDefinition SubTypeDefinition() throws ParseException {
15604  /*@bgen(jjtree) SubTypeDefinition */
15605         ASTSubTypeDefinition jjtn000 = new ASTSubTypeDefinition(this, JJTSUBTYPEDEFINITION);
15606         boolean jjtc000 = true;
15607         jjtree.openNodeScope(jjtn000);Token start, subtype_name=null, constraint=null, base_type=null;
15608         Token collection = null, collection2 = null;
15609         PLSQLNode name = null;
15610         PLSQLNode startElement = null, endElement = null;
15611         PLSQLNode baseType = null, returnType = null, indexBy = null ;
15612         int lastField = 0;
15613     try {
15614       switch (jj_nt.kind) {
15615       case SUBTYPE:
15616         jj_consume_token(SUBTYPE);
15617         name = QualifiedID();
15618         jj_consume_token(IS);
15619         Datatype();
15620         switch (jj_nt.kind) {
15621         case 5:
15622         case RANGE:
15623           switch (jj_nt.kind) {
15624           case 5:
15625             jj_consume_token(5);
15626             jj_consume_token(IDENTIFIER);
15627             jj_consume_token(7);
15628             break;
15629           case RANGE:
15630             jj_consume_token(RANGE);
15631             UnaryExpression(true);
15632             jj_consume_token(12);
15633             UnaryExpression(true);
15634             break;
15635           default:
15636             jj_la1[182] = jj_gen;
15637             jj_consume_token(-1);
15638             throw new ParseException();
15639           }
15640           break;
15641         default:
15642           jj_la1[183] = jj_gen;
15643           ;
15644         }
15645         switch (jj_nt.kind) {
15646         case NOT:
15647           jj_consume_token(NOT);
15648           jj_consume_token(NULL);
15649           break;
15650         default:
15651           jj_la1[184] = jj_gen;
15652           ;
15653         }
15654         break;
15655       case TYPE:
15656         jj_consume_token(TYPE);
15657         name = QualifiedID();
15658         switch (jj_nt.kind) {
15659         case IS:
15660           jj_consume_token(IS);
15661           break;
15662         case AS:
15663           jj_consume_token(AS);
15664           break;
15665         default:
15666           jj_la1[185] = jj_gen;
15667           jj_consume_token(-1);
15668           throw new ParseException();
15669         }
15670         if (jj_2_44(2)) {
15671           jj_consume_token(NEW);
15672           switch (jj_nt.kind) {
15673           case CHAR_BASE:
15674             jj_consume_token(CHAR_BASE);
15675             break;
15676           case DATE_BASE:
15677             jj_consume_token(DATE_BASE);
15678             break;
15679           case CLOB_BASE:
15680             jj_consume_token(CLOB_BASE);
15681             break;
15682           case BLOB_BASE:
15683             jj_consume_token(BLOB_BASE);
15684             break;
15685           case BFILE_BASE:
15686             jj_consume_token(BFILE_BASE);
15687             break;
15688           case NUMBER_BASE:
15689             jj_consume_token(NUMBER_BASE);
15690             break;
15691           default:
15692             jj_la1[186] = jj_gen;
15693             jj_consume_token(-1);
15694             throw new ParseException();
15695           }
15696         } else {
15697           switch (jj_nt.kind) {
15698           case OBJECT:
15699             jj_consume_token(OBJECT);
15700             jj_consume_token(5);
15701             FieldDeclaration();
15702             label_44:
15703             while (true) {
15704               switch (jj_nt.kind) {
15705               case 6:
15706                 ;
15707                 break;
15708               default:
15709                 jj_la1[187] = jj_gen;
15710                 break label_44;
15711               }
15712               jj_consume_token(6);
15713               FieldDeclaration();
15714             }
15715             jj_consume_token(7);
15716             break;
15717           case RECORD:
15718             jj_consume_token(RECORD);
15719             jj_consume_token(5);
15720             FieldDeclaration();
15721             label_45:
15722             while (true) {
15723               switch (jj_nt.kind) {
15724               case 6:
15725                 ;
15726                 break;
15727               default:
15728                 jj_la1[188] = jj_gen;
15729                 break label_45;
15730               }
15731               jj_consume_token(6);
15732               FieldDeclaration();
15733             }
15734             jj_consume_token(7);
15735             break;
15736           case TABLE:
15737           case VARRAY:
15738           case VARYING:
15739             switch (jj_nt.kind) {
15740             case TABLE:
15741               jj_consume_token(TABLE);
15742               break;
15743             case VARRAY:
15744               jj_consume_token(VARRAY);
15745               break;
15746             case VARYING:
15747               jj_consume_token(VARYING);
15748               jj_consume_token(ARRAY);
15749               break;
15750             default:
15751               jj_la1[189] = jj_gen;
15752               jj_consume_token(-1);
15753               throw new ParseException();
15754             }
15755             switch (jj_nt.kind) {
15756             case 5:
15757               jj_consume_token(5);
15758               NumericLiteral();
15759               jj_consume_token(7);
15760               break;
15761             default:
15762               jj_la1[190] = jj_gen;
15763               ;
15764             }
15765             jj_consume_token(OF);
15766             Datatype();
15767             switch (jj_nt.kind) {
15768             case NOT:
15769               jj_consume_token(NOT);
15770               jj_consume_token(NULL);
15771               break;
15772             default:
15773               jj_la1[191] = jj_gen;
15774               ;
15775             }
15776             switch (jj_nt.kind) {
15777             case INDEX:
15778               jj_consume_token(INDEX);
15779               jj_consume_token(BY);
15780               Datatype();
15781               break;
15782             default:
15783               jj_la1[192] = jj_gen;
15784               ;
15785             }
15786             break;
15787           case REF:
15788             jj_consume_token(REF);
15789             jj_consume_token(CURSOR);
15790             switch (jj_nt.kind) {
15791             case RETURN:
15792               jj_consume_token(RETURN);
15793               Datatype();
15794               break;
15795             default:
15796               jj_la1[193] = jj_gen;
15797               ;
15798             }
15799             break;
15800           case 5:
15801             jj_consume_token(5);
15802             Expression();
15803             label_46:
15804             while (true) {
15805               switch (jj_nt.kind) {
15806               case 6:
15807                 ;
15808                 break;
15809               default:
15810                 jj_la1[194] = jj_gen;
15811                 break label_46;
15812               }
15813               jj_consume_token(6);
15814               Expression();
15815             }
15816             jj_consume_token(7);
15817             break;
15818           case REPLACE:
15819           case DEFINER:
15820           case CURRENT_USER:
15821           case LANGUAGE:
15822           case INLINE:
15823           case ADD:
15824           case AGGREGATE:
15825           case ARRAY:
15826           case AT:
15827           case ATTRIBUTE:
15828           case AUTHID:
15829           case BINARY_INTEGER:
15830           case BODY:
15831           case BOOLEAN:
15832           case BULK:
15833           case BYTE:
15834           case CASCADE:
15835           case CHAR:
15836           case CHAR_BASE:
15837           case CLOSE:
15838           case COALESCE:
15839           case COLLECT:
15840           case COLUMN:
15841           case COMMENT:
15842           case COMMIT:
15843           case CONSTRUCTOR:
15844           case CONTINUE:
15845           case CONVERT:
15846           case CURRENT:
15847           case CURSOR:
15848           case DATA:
15849           case DATE:
15850           case DAY:
15851           case DECIMAL:
15852           case DISABLE:
15853           case EDITIONABLE:
15854           case ELEMENT:
15855           case ENABLE:
15856           case ESCAPE:
15857           case EXCEPT:
15858           case EXCEPTIONS:
15859           case EXIT:
15860           case EXTERNAL:
15861           case EXTENDS:
15862           case EXTRACT:
15863           case FALSE:
15864           case FINAL:
15865           case FLOAT:
15866           case FORCE:
15867           case FUNCTION:
15868           case GLOBAL:
15869           case HASH:
15870           case HEAP:
15871           case HOUR:
15872           case IMMEDIATE:
15873           case INDICES:
15874           case INDEXTYPE:
15875           case INDICATOR:
15876           case INSTANTIABLE:
15877           case INTEGER:
15878           case INTERVAL:
15879           case INVALIDATE:
15880           case ISOLATION:
15881           case JAVA:
15882           case LEVEL:
15883           case LIMIT:
15884           case LONG:
15885           case LOOP:
15886           case MAP:
15887           case MAX:
15888           case MEMBER:
15889           case MERGE:
15890           case MIN:
15891           case MINUTE:
15892           case MLSLABEL:
15893           case MODIFY:
15894           case MOD:
15895           case MONTH:
15896           case NATURAL:
15897           case NATURALN:
15898           case NEW:
15899           case NO:
15900           case NONEDITIONABLE:
15901           case NULLIF:
15902           case NUMBER:
15903           case BFILE_BASE:
15904           case BLOB_BASE:
15905           case CLOB_BASE:
15906           case DATE_BASE:
15907           case NUMBER_BASE:
15908           case OID:
15909           case OPAQUE:
15910           case OPEN:
15911           case OPERATOR:
15912           case ORGANIZATION:
15913           case OTHERS:
15914           case OVERRIDING:
15915           case PACKAGE:
15916           case PARTITION:
15917           case PLS_INTEGER:
15918           case POSITIVE:
15919           case POSITIVEN:
15920           case PRESERVE:
15921           case PRIVATE:
15922           case PROCEDURE:
15923           case RANGE:
15924           case RAW:
15925           case REAL:
15926           case RELEASE:
15927           case RELIES_ON:
15928           case RENAME:
15929           case RESULT:
15930           case RETURN:
15931           case RETURNING:
15932           case REVERSE:
15933           case ROLLBACK:
15934           case ROW:
15935           case ROWS:
15936           case ROWID:
15937           case ROWNUM:
15938           case SAVE:
15939           case SAVEPOINT:
15940           case SECOND:
15941           case SELF:
15942           case SET:
15943           case SMALLINT:
15944           case SPACE:
15945           case SQL:
15946           case SQLCODE:
15947           case SQLERRM:
15948           case STATIC:
15949           case SUBTYPE:
15950           case SUBSTITUTABLE:
15951           case SUCCESSFUL:
15952           case SYSDATE:
15953           case SYS_REFCURSOR:
15954           case TEMPORARY:
15955           case TIME:
15956           case TIMESTAMP:
15957           case TIMEZONE_REGION:
15958           case TIMEZONE_ABBR:
15959           case TIMEZONE_MINUTE:
15960           case TIMEZONE_HOUR:
15961           case TRANSACTION:
15962           case TRUE:
15963           case TYPE:
15964           case UNDER:
15965           case USING:
15966           case YES:
15967           case SHOW:
15968           case A:
15969           case VARCHAR:
15970           case VARCHAR2:
15971           case DOUBLE:
15972           case DEC:
15973           case PRECISION:
15974           case INT:
15975           case NUMERIC:
15976           case SIGNTYPE:
15977           case NCHAR:
15978           case NVARCHAR2:
15979           case STRING:
15980           case UROWID:
15981           case BFILE:
15982           case BLOB:
15983           case CLOB:
15984           case NCLOB:
15985           case YEAR:
15986           case LOCAL:
15987           case ZONE:
15988           case CHARACTER:
15989           case AFTER:
15990           case BEFORE:
15991           case OLD:
15992           case PARENT:
15993           case CC_IF:
15994           case ANALYZE:
15995           case ASSOCIATE:
15996           case AUDIT:
15997           case COMPOUND:
15998           case DATABASE:
15999           case CALL:
16000           case DDL:
16001           case DISASSOCIATE:
16002           case EACH:
16003           case FOLLOWS:
16004           case LOGOFF:
16005           case LOGON:
16006           case NESTED:
16007           case NOAUDIT:
16008           case SCHEMA:
16009           case SERVERERROR:
16010           case SHUTDOWN:
16011           case STARTUP:
16012           case STATEMENT:
16013           case STATISTICS:
16014           case SUSPEND:
16015           case TRUNCATE:
16016           case WRAPPED:
16017           case LIBRARY:
16018           case NAME:
16019           case STRUCT:
16020           case CONTEXT:
16021           case PARAMETERS:
16022           case LENGTH:
16023           case TDO:
16024           case MAXLEN:
16025           case CHARSETID:
16026           case CHARSETFORM:
16027           case ACCEPT:
16028           case ACCESSIBLE:
16029           case COPY:
16030           case DEFINE:
16031           case DISCONNECT:
16032           case HOST:
16033           case PRINT:
16034           case QUIT:
16035           case REMARK:
16036           case UNDEFINE:
16037           case VARIABLE:
16038           case WHENEVER:
16039           case ATTACH:
16040           case CAST:
16041           case TREAT:
16042           case TRIM:
16043           case LEFT:
16044           case RIGHT:
16045           case BOTH:
16046           case EMPTY:
16047           case MULTISET:
16048           case SUBMULTISET:
16049           case LEADING:
16050           case TRAILING:
16051           case CHAR_CS:
16052           case NCHAR_CS:
16053           case DBTIMEZONE:
16054           case SESSIONTIMEZONE:
16055           case AUTHENTICATED:
16056           case LINK:
16057           case SHARED:
16058           case DIRECTORY:
16059           case USER:
16060           case IDENTIFIER:
16061           case QUOTED_LITERAL:
16062             Datatype();
16063             break;
16064           default:
16065             jj_la1[195] = jj_gen;
16066             jj_consume_token(-1);
16067             throw new ParseException();
16068           }
16069         }
16070         break;
16071       default:
16072         jj_la1[196] = jj_gen;
16073         jj_consume_token(-1);
16074         throw new ParseException();
16075       }
16076       jj_consume_token(4);
16077         jjtree.closeNodeScope(jjtn000, true);
16078         jjtc000 = false;
16079         jjtn000.setImage(name.getImage()) ;  {if (true) return jjtn000 ;}
16080     } catch (Throwable jjte000) {
16081           if (jjtc000) {
16082             jjtree.clearNodeScope(jjtn000);
16083             jjtc000 = false;
16084           } else {
16085             jjtree.popNode();
16086           }
16087           if (jjte000 instanceof RuntimeException) {
16088             {if (true) throw (RuntimeException)jjte000;}
16089           }
16090           if (jjte000 instanceof ParseException) {
16091             {if (true) throw (ParseException)jjte000;}
16092           }
16093           {if (true) throw (Error)jjte000;}
16094     } finally {
16095           if (jjtc000) {
16096             jjtree.closeNodeScope(jjtn000, true);
16097           }
16098     }
16099     throw new Error("Missing return statement in function");
16100   }
16101 
16102   final public ASTFieldDeclaration FieldDeclaration() throws ParseException {
16103  /*@bgen(jjtree) FieldDeclaration */
16104         ASTFieldDeclaration jjtn000 = new ASTFieldDeclaration(this, JJTFIELDDECLARATION);
16105         boolean jjtc000 = true;
16106         jjtree.openNodeScope(jjtn000);PLSQLNode name;
16107         PLSQLNode dataType;
16108         PLSQLNode defaultValue = null;
16109     try {
16110       name = ID();
16111       Datatype();
16112       switch (jj_nt.kind) {
16113       case NOT:
16114       case NULL:
16115         switch (jj_nt.kind) {
16116         case NOT:
16117           jj_consume_token(NOT);
16118           break;
16119         default:
16120           jj_la1[197] = jj_gen;
16121           ;
16122         }
16123         jj_consume_token(NULL);
16124         break;
16125       default:
16126         jj_la1[198] = jj_gen;
16127         ;
16128       }
16129       switch (jj_nt.kind) {
16130       case 9:
16131       case _DEFAULT:
16132         switch (jj_nt.kind) {
16133         case 9:
16134           jj_consume_token(9);
16135           jj_consume_token(10);
16136           break;
16137         case _DEFAULT:
16138           jj_consume_token(_DEFAULT);
16139           break;
16140         default:
16141           jj_la1[199] = jj_gen;
16142           jj_consume_token(-1);
16143           throw new ParseException();
16144         }
16145         Expression();
16146         break;
16147       default:
16148         jj_la1[200] = jj_gen;
16149         ;
16150       }
16151         jjtree.closeNodeScope(jjtn000, true);
16152         jjtc000 = false;
16153         jjtn000.setImage(name.getImage()) ;  {if (true) return jjtn000 ;}
16154     } catch (Throwable jjte000) {
16155           if (jjtc000) {
16156             jjtree.clearNodeScope(jjtn000);
16157             jjtc000 = false;
16158           } else {
16159             jjtree.popNode();
16160           }
16161           if (jjte000 instanceof RuntimeException) {
16162             {if (true) throw (RuntimeException)jjte000;}
16163           }
16164           if (jjte000 instanceof ParseException) {
16165             {if (true) throw (ParseException)jjte000;}
16166           }
16167           {if (true) throw (Error)jjte000;}
16168     } finally {
16169           if (jjtc000) {
16170             jjtree.closeNodeScope(jjtn000, true);
16171           }
16172     }
16173     throw new Error("Missing return statement in function");
16174   }
16175 
16176   final public ASTCollectionTypeDefinition CollectionTypeDefinition() throws ParseException {
16177                                                           /*@bgen(jjtree) CollectionTypeDefinition */
16178                                                           ASTCollectionTypeDefinition jjtn000 = new ASTCollectionTypeDefinition(this, JJTCOLLECTIONTYPEDEFINITION);
16179                                                           boolean jjtc000 = true;
16180                                                           jjtree.openNodeScope(jjtn000);Token t = null ;
16181     try {
16182       t = jj_consume_token(IDENTIFIER);
16183                                                                                                   jjtree.closeNodeScope(jjtn000, true);
16184                                                                                                   jjtc000 = false;
16185                                                                                                   jjtn000.setImage(t.image) ;  {if (true) return jjtn000 ;}
16186     } finally {
16187                                                                                  if (jjtc000) {
16188                                                                                    jjtree.closeNodeScope(jjtn000, true);
16189                                                                                  }
16190     }
16191     throw new Error("Missing return statement in function");
16192   }
16193 
16194   final public ASTCollectionDeclaration CollectionDeclaration() throws ParseException {
16195                                                     /*@bgen(jjtree) CollectionDeclaration */
16196                                                     ASTCollectionDeclaration jjtn000 = new ASTCollectionDeclaration(this, JJTCOLLECTIONDECLARATION);
16197                                                     boolean jjtc000 = true;
16198                                                     jjtree.openNodeScope(jjtn000);Token t = null ;
16199     try {
16200       t = jj_consume_token(IDENTIFIER);
16201                                                                                             jjtree.closeNodeScope(jjtn000, true);
16202                                                                                             jjtc000 = false;
16203                                                                                             jjtn000.setImage(t.image) ;  {if (true) return jjtn000 ;}
16204     } finally {
16205                                                                            if (jjtc000) {
16206                                                                              jjtree.closeNodeScope(jjtn000, true);
16207                                                                            }
16208     }
16209     throw new Error("Missing return statement in function");
16210   }
16211 
16212   final public ASTObjectDeclaration ObjectDeclaration() throws ParseException {
16213                                             /*@bgen(jjtree) ObjectDeclaration */
16214                                             ASTObjectDeclaration jjtn000 = new ASTObjectDeclaration(this, JJTOBJECTDECLARATION);
16215                                             boolean jjtc000 = true;
16216                                             jjtree.openNodeScope(jjtn000);Token t = null ;
16217     try {
16218       t = jj_consume_token(IDENTIFIER);
16219                                                                                     jjtree.closeNodeScope(jjtn000, true);
16220                                                                                     jjtc000 = false;
16221                                                                                     jjtn000.setImage(t.image) ;  {if (true) return jjtn000 ;}
16222     } finally {
16223                                                                    if (jjtc000) {
16224                                                                      jjtree.closeNodeScope(jjtn000, true);
16225                                                                    }
16226     }
16227     throw new Error("Missing return statement in function");
16228   }
16229 
16230 /** Java stored procedure, external function*/
16231   final public ASTCallSpecTail CallSpecTail() throws ParseException {
16232                                   /*@bgen(jjtree) CallSpecTail */
16233   ASTCallSpecTail jjtn000 = new ASTCallSpecTail(this, JJTCALLSPECTAIL);
16234   boolean jjtc000 = true;
16235   jjtree.openNodeScope(jjtn000);
16236     try {
16237       switch (jj_nt.kind) {
16238       case EXTERNAL:
16239         jj_consume_token(EXTERNAL);
16240         break;
16241       case LANGUAGE:
16242         jj_consume_token(LANGUAGE);
16243         switch (jj_nt.kind) {
16244         case IDENTIFIER:
16245           jj_consume_token(IDENTIFIER);
16246           break;
16247         case JAVA:
16248           jj_consume_token(JAVA);
16249           break;
16250         default:
16251           jj_la1[201] = jj_gen;
16252           jj_consume_token(-1);
16253           throw new ParseException();
16254         }
16255         break;
16256       default:
16257         jj_la1[202] = jj_gen;
16258         jj_consume_token(-1);
16259         throw new ParseException();
16260       }
16261       label_47:
16262       while (true) {
16263         switch (jj_nt.kind) {
16264         case WITH:
16265         case LIBRARY:
16266         case NAME:
16267         case PARAMETERS:
16268           ;
16269           break;
16270         default:
16271           jj_la1[203] = jj_gen;
16272           break label_47;
16273         }
16274         switch (jj_nt.kind) {
16275         case LIBRARY:
16276           jj_consume_token(LIBRARY);
16277           switch (jj_nt.kind) {
16278           case IDENTIFIER:
16279             jj_consume_token(IDENTIFIER);
16280             break;
16281           case QUOTED_LITERAL:
16282             jj_consume_token(QUOTED_LITERAL);
16283             break;
16284           case STRING_LITERAL:
16285             StringLiteral();
16286             break;
16287           default:
16288             jj_la1[204] = jj_gen;
16289             jj_consume_token(-1);
16290             throw new ParseException();
16291           }
16292           switch (jj_nt.kind) {
16293           case 3:
16294             jj_consume_token(3);
16295             switch (jj_nt.kind) {
16296             case IDENTIFIER:
16297               jj_consume_token(IDENTIFIER);
16298               break;
16299             case QUOTED_LITERAL:
16300               jj_consume_token(QUOTED_LITERAL);
16301               break;
16302             case STRING_LITERAL:
16303               StringLiteral();
16304               break;
16305             default:
16306               jj_la1[205] = jj_gen;
16307               jj_consume_token(-1);
16308               throw new ParseException();
16309             }
16310             break;
16311           default:
16312             jj_la1[206] = jj_gen;
16313             ;
16314           }
16315           break;
16316         case NAME:
16317           jj_consume_token(NAME);
16318           switch (jj_nt.kind) {
16319           case IDENTIFIER:
16320             jj_consume_token(IDENTIFIER);
16321             break;
16322           case QUOTED_LITERAL:
16323             jj_consume_token(QUOTED_LITERAL);
16324             break;
16325           case STRING_LITERAL:
16326             StringLiteral();
16327             break;
16328           default:
16329             jj_la1[207] = jj_gen;
16330             jj_consume_token(-1);
16331             throw new ParseException();
16332           }
16333           break;
16334         case WITH:
16335           jj_consume_token(WITH);
16336           jj_consume_token(CONTEXT);
16337           break;
16338         case PARAMETERS:
16339           jj_consume_token(PARAMETERS);
16340           SkipPastNextOccurrence(")");
16341           break;
16342         default:
16343           jj_la1[208] = jj_gen;
16344           jj_consume_token(-1);
16345           throw new ParseException();
16346         }
16347       }
16348         jjtree.closeNodeScope(jjtn000, true);
16349         jjtc000 = false;
16350         {if (true) return jjtn000 ;}
16351     } catch (Throwable jjte000) {
16352           if (jjtc000) {
16353             jjtree.clearNodeScope(jjtn000);
16354             jjtc000 = false;
16355           } else {
16356             jjtree.popNode();
16357           }
16358           if (jjte000 instanceof RuntimeException) {
16359             {if (true) throw (RuntimeException)jjte000;}
16360           }
16361           if (jjte000 instanceof ParseException) {
16362             {if (true) throw (ParseException)jjte000;}
16363           }
16364           {if (true) throw (Error)jjte000;}
16365     } finally {
16366           if (jjtc000) {
16367             jjtree.closeNodeScope(jjtn000, true);
16368           }
16369     }
16370     throw new Error("Missing return statement in function");
16371   }
16372 
16373 /** Cursor (common part of specification and body) */
16374   final public ASTCursorUnit CursorUnit() throws ParseException {
16375  /*@bgen(jjtree) CursorUnit */
16376  ASTCursorUnit jjtn000 = new ASTCursorUnit(this, JJTCURSORUNIT);
16377  boolean jjtc000 = true;
16378  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
16379     try {
16380       jj_consume_token(CURSOR);
16381       simpleNode = ID();
16382       switch (jj_nt.kind) {
16383       case 5:
16384         FormalParameters();
16385         break;
16386       default:
16387         jj_la1[209] = jj_gen;
16388         ;
16389       }
16390       switch (jj_nt.kind) {
16391       case RETURN:
16392         jj_consume_token(RETURN);
16393         Datatype();
16394         break;
16395       default:
16396         jj_la1[210] = jj_gen;
16397         ;
16398       }
16399       switch (jj_nt.kind) {
16400       case IS:
16401         jj_consume_token(IS);
16402         label_48:
16403         while (true) {
16404           switch (jj_nt.kind) {
16405           case 5:
16406             ;
16407             break;
16408           default:
16409             jj_la1[211] = jj_gen;
16410             break label_48;
16411           }
16412           jj_consume_token(5);
16413         }
16414         SqlStatement(null,";");
16415         break;
16416       default:
16417         jj_la1[212] = jj_gen;
16418         ;
16419       }
16420       jj_consume_token(4);
16421         jjtree.closeNodeScope(jjtn000, true);
16422         jjtc000 = false;
16423         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
16424     } catch (Throwable jjte000) {
16425           if (jjtc000) {
16426             jjtree.clearNodeScope(jjtn000);
16427             jjtc000 = false;
16428           } else {
16429             jjtree.popNode();
16430           }
16431           if (jjte000 instanceof RuntimeException) {
16432             {if (true) throw (RuntimeException)jjte000;}
16433           }
16434           if (jjte000 instanceof ParseException) {
16435             {if (true) throw (ParseException)jjte000;}
16436           }
16437           {if (true) throw (Error)jjte000;}
16438     } finally {
16439           if (jjtc000) {
16440             jjtree.closeNodeScope(jjtn000, true);
16441           }
16442     }
16443     throw new Error("Missing return statement in function");
16444   }
16445 
16446   final public ASTCursorSpecification CursorSpecification() throws ParseException {
16447                                                  /*@bgen(jjtree) CursorSpecification */
16448   ASTCursorSpecification jjtn000 = new ASTCursorSpecification(this, JJTCURSORSPECIFICATION);
16449   boolean jjtc000 = true;
16450   jjtree.openNodeScope(jjtn000);
16451     try {
16452       CursorUnit();
16453         jjtree.closeNodeScope(jjtn000, true);
16454         jjtc000 = false;
16455         {if (true) return jjtn000 ;}
16456     } catch (Throwable jjte000) {
16457           if (jjtc000) {
16458             jjtree.clearNodeScope(jjtn000);
16459             jjtc000 = false;
16460           } else {
16461             jjtree.popNode();
16462           }
16463           if (jjte000 instanceof RuntimeException) {
16464             {if (true) throw (RuntimeException)jjte000;}
16465           }
16466           if (jjte000 instanceof ParseException) {
16467             {if (true) throw (ParseException)jjte000;}
16468           }
16469           {if (true) throw (Error)jjte000;}
16470     } finally {
16471           if (jjtc000) {
16472             jjtree.closeNodeScope(jjtn000, true);
16473           }
16474     }
16475     throw new Error("Missing return statement in function");
16476   }
16477 
16478   final public ASTCursorBody CursorBody() throws ParseException {
16479                                /*@bgen(jjtree) CursorBody */
16480   ASTCursorBody jjtn000 = new ASTCursorBody(this, JJTCURSORBODY);
16481   boolean jjtc000 = true;
16482   jjtree.openNodeScope(jjtn000);
16483     try {
16484       CursorUnit();
16485         jjtree.closeNodeScope(jjtn000, true);
16486         jjtc000 = false;
16487         {if (true) return jjtn000 ;}
16488     } catch (Throwable jjte000) {
16489           if (jjtc000) {
16490             jjtree.clearNodeScope(jjtn000);
16491             jjtc000 = false;
16492           } else {
16493             jjtree.popNode();
16494           }
16495           if (jjte000 instanceof RuntimeException) {
16496             {if (true) throw (RuntimeException)jjte000;}
16497           }
16498           if (jjte000 instanceof ParseException) {
16499             {if (true) throw (ParseException)jjte000;}
16500           }
16501           {if (true) throw (Error)jjte000;}
16502     } finally {
16503           if (jjtc000) {
16504             jjtree.closeNodeScope(jjtn000, true);
16505           }
16506     }
16507     throw new Error("Missing return statement in function");
16508   }
16509 
16510 // ============================================================================
16511 // E X P R E S S I O N S
16512 // ============================================================================
16513 
16514 /*
16515 String expression() :
16516 {}
16517 {
16518 	"test"
16519 	{ return ""; }
16520 }
16521 */
16522   final public ASTExpression Expression() throws ParseException {
16523  /*@bgen(jjtree) Expression */
16524   ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
16525   boolean jjtc000 = true;
16526   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16527   StringBuilder sb = new StringBuilder() ;
16528     try {
16529       if (jj_2_45(2147483647)) {
16530         simpleNode = Assignment();
16531                                                                               sb.append(simpleNode.getImage());
16532       } else {
16533         switch (jj_nt.kind) {
16534         case 5:
16535         case 16:
16536         case 17:
16537         case REPLACE:
16538         case DEFINER:
16539         case CURRENT_USER:
16540         case LANGUAGE:
16541         case INLINE:
16542         case ADD:
16543         case AGGREGATE:
16544         case ARRAY:
16545         case AT:
16546         case ATTRIBUTE:
16547         case AUTHID:
16548         case BODY:
16549         case BULK:
16550         case BYTE:
16551         case CASCADE:
16552         case CASE:
16553         case CLOSE:
16554         case COALESCE:
16555         case COLLECT:
16556         case COLUMN:
16557         case COMMENT:
16558         case COMMIT:
16559         case CONSTRUCTOR:
16560         case CONTINUE:
16561         case CONVERT:
16562         case CURRENT:
16563         case CURSOR:
16564         case DATA:
16565         case DATE:
16566         case DAY:
16567         case DISABLE:
16568         case EDITIONABLE:
16569         case ELEMENT:
16570         case ENABLE:
16571         case ESCAPE:
16572         case EXCEPT:
16573         case EXCEPTIONS:
16574         case EXIT:
16575         case EXTERNAL:
16576         case EXTENDS:
16577         case EXTRACT:
16578         case FALSE:
16579         case FINAL:
16580         case FORCE:
16581         case FUNCTION:
16582         case GLOBAL:
16583         case HASH:
16584         case HEAP:
16585         case HOUR:
16586         case IMMEDIATE:
16587         case INDICES:
16588         case INDEXTYPE:
16589         case INDICATOR:
16590         case INSTANTIABLE:
16591         case INTERVAL:
16592         case INVALIDATE:
16593         case ISOLATION:
16594         case JAVA:
16595         case LEVEL:
16596         case LIMIT:
16597         case LOOP:
16598         case MAP:
16599         case MAX:
16600         case MEMBER:
16601         case MERGE:
16602         case MIN:
16603         case MINUTE:
16604         case MLSLABEL:
16605         case MODIFY:
16606         case MOD:
16607         case MONTH:
16608         case NATURAL:
16609         case NEW:
16610         case NEW_DOT:
16611         case NO:
16612         case NONEDITIONABLE:
16613         case NOT:
16614         case NULL:
16615         case NULLIF:
16616         case OBJECT:
16617         case OID:
16618         case OPAQUE:
16619         case OPEN:
16620         case OPERATOR:
16621         case ORGANIZATION:
16622         case OTHERS:
16623         case OVERRIDING:
16624         case PACKAGE:
16625         case PARTITION:
16626         case PRESERVE:
16627         case PRIVATE:
16628         case PROCEDURE:
16629         case RANGE:
16630         case RAW:
16631         case REAL:
16632         case RECORD:
16633         case REF:
16634         case RELEASE:
16635         case RELIES_ON:
16636         case RENAME:
16637         case RESULT:
16638         case RETURN:
16639         case RETURNING:
16640         case REVERSE:
16641         case ROLLBACK:
16642         case ROW:
16643         case ROWS:
16644         case ROWID:
16645         case ROWNUM:
16646         case SAVE:
16647         case SAVEPOINT:
16648         case SECOND:
16649         case SELECT:
16650         case SELF:
16651         case SET:
16652         case SPACE:
16653         case SQL:
16654         case SQLCODE:
16655         case SQLERRM:
16656         case STATIC:
16657         case SUBTYPE:
16658         case SUBSTITUTABLE:
16659         case SUCCESSFUL:
16660         case SYSDATE:
16661         case SYS_REFCURSOR:
16662         case TEMPORARY:
16663         case TIME:
16664         case TIMESTAMP:
16665         case TIMEZONE_REGION:
16666         case TIMEZONE_ABBR:
16667         case TIMEZONE_MINUTE:
16668         case TIMEZONE_HOUR:
16669         case TRANSACTION:
16670         case TRUE:
16671         case TYPE:
16672         case UNDER:
16673         case USING:
16674         case YES:
16675         case SHOW:
16676         case A:
16677         case DOUBLE:
16678         case DEC:
16679         case PRECISION:
16680         case INT:
16681         case NUMERIC:
16682         case NCHAR:
16683         case NVARCHAR2:
16684         case STRING:
16685         case UROWID:
16686         case VARRAY:
16687         case VARYING:
16688         case BFILE:
16689         case BLOB:
16690         case CLOB:
16691         case NCLOB:
16692         case YEAR:
16693         case LOCAL:
16694         case WITH:
16695         case ZONE:
16696         case CHARACTER:
16697         case AFTER:
16698         case BEFORE:
16699         case OLD:
16700         case PARENT:
16701         case ANALYZE:
16702         case ASSOCIATE:
16703         case AUDIT:
16704         case COMPOUND:
16705         case DATABASE:
16706         case CALL:
16707         case DDL:
16708         case DISASSOCIATE:
16709         case EACH:
16710         case FOLLOWS:
16711         case LOGOFF:
16712         case LOGON:
16713         case NESTED:
16714         case NOAUDIT:
16715         case SCHEMA:
16716         case SERVERERROR:
16717         case SHUTDOWN:
16718         case STARTUP:
16719         case STATEMENT:
16720         case STATISTICS:
16721         case SUSPEND:
16722         case TRUNCATE:
16723         case WRAPPED:
16724         case LIBRARY:
16725         case NAME:
16726         case STRUCT:
16727         case CONTEXT:
16728         case PARAMETERS:
16729         case LENGTH:
16730         case TDO:
16731         case MAXLEN:
16732         case CHARSETID:
16733         case CHARSETFORM:
16734         case ACCEPT:
16735         case ACCESSIBLE:
16736         case COPY:
16737         case DEFINE:
16738         case DISCONNECT:
16739         case HOST:
16740         case PRINT:
16741         case QUIT:
16742         case REMARK:
16743         case UNDEFINE:
16744         case VARIABLE:
16745         case WHENEVER:
16746         case ATTACH:
16747         case CAST:
16748         case TREAT:
16749         case TRIM:
16750         case LEFT:
16751         case RIGHT:
16752         case BOTH:
16753         case EMPTY:
16754         case MULTISET:
16755         case SUBMULTISET:
16756         case LEADING:
16757         case TRAILING:
16758         case CHAR_CS:
16759         case NCHAR_CS:
16760         case DBTIMEZONE:
16761         case SESSIONTIMEZONE:
16762         case AUTHENTICATED:
16763         case LINK:
16764         case SHARED:
16765         case DIRECTORY:
16766         case USER:
16767         case IDENTIFIER:
16768         case UNSIGNED_NUMERIC_LITERAL:
16769         case CHARACTER_LITERAL:
16770         case STRING_LITERAL:
16771         case QUOTED_LITERAL:
16772           simpleNode = ConditionalOrExpression();
16773                                                       sb.append(simpleNode.getImage());
16774           break;
16775         case CC_IF:
16776           simpleNode = CompilationExpression();
16777                                                     sb.append(simpleNode.getImage());
16778           break;
16779         default:
16780           jj_la1[213] = jj_gen;
16781           jj_consume_token(-1);
16782           throw new ParseException();
16783         }
16784       }
16785    jjtree.closeNodeScope(jjtn000, true);
16786    jjtc000 = false;
16787  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16788     } catch (Throwable jjte000) {
16789           if (jjtc000) {
16790             jjtree.clearNodeScope(jjtn000);
16791             jjtc000 = false;
16792           } else {
16793             jjtree.popNode();
16794           }
16795           if (jjte000 instanceof RuntimeException) {
16796             {if (true) throw (RuntimeException)jjte000;}
16797           }
16798           if (jjte000 instanceof ParseException) {
16799             {if (true) throw (ParseException)jjte000;}
16800           }
16801           {if (true) throw (Error)jjte000;}
16802     } finally {
16803           if (jjtc000) {
16804             jjtree.closeNodeScope(jjtn000, true);
16805           }
16806     }
16807     throw new Error("Missing return statement in function");
16808   }
16809 
16810   final public ASTCompilationExpression CompilationExpression() throws ParseException {
16811  /*@bgen(jjtree) CompilationExpression */
16812   ASTCompilationExpression jjtn000 = new ASTCompilationExpression(this, JJTCOMPILATIONEXPRESSION);
16813   boolean jjtc000 = true;
16814   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16815   StringBuilder sb = new StringBuilder() ;
16816     try {
16817       jj_consume_token(CC_IF);
16818                    sb.append(" "); sb.append(token.image) ;
16819       simpleNode = ConditionalOrExpression();
16820                                                    sb.append(" "); sb.append(simpleNode.getImage());
16821       jj_consume_token(CC_THEN);
16822                      sb.append(" "); sb.append(token.image);
16823       simpleNode = Expression();
16824                                      sb.append(" "); sb.append(simpleNode.getImage());
16825       label_49:
16826       while (true) {
16827         switch (jj_nt.kind) {
16828         case CC_ELSIF:
16829           ;
16830           break;
16831         default:
16832           jj_la1[214] = jj_gen;
16833           break label_49;
16834         }
16835         jj_consume_token(CC_ELSIF);
16836                         sb.append(" "); sb.append(token.image);
16837         simpleNode = ConditionalOrExpression();
16838                                                     sb.append(" "); sb.append(simpleNode.getImage());
16839         jj_consume_token(CC_THEN);
16840                        sb.append(" "); sb.append(token.image);
16841         simpleNode = Expression();
16842                                        sb.append(" "); sb.append(simpleNode.getImage());
16843       }
16844       label_50:
16845       while (true) {
16846         switch (jj_nt.kind) {
16847         case CC_ELSE:
16848           ;
16849           break;
16850         default:
16851           jj_la1[215] = jj_gen;
16852           break label_50;
16853         }
16854         jj_consume_token(CC_ELSE);
16855                        sb.append(" "); sb.append(token.image);
16856         simpleNode = Expression();
16857                                         sb.append(" "); sb.append(simpleNode.getImage());
16858       }
16859       jj_consume_token(CC_END);
16860                     sb.append(" "); sb.append(token.image);
16861    jjtree.closeNodeScope(jjtn000, true);
16862    jjtc000 = false;
16863  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16864     } catch (Throwable jjte000) {
16865           if (jjtc000) {
16866             jjtree.clearNodeScope(jjtn000);
16867             jjtc000 = false;
16868           } else {
16869             jjtree.popNode();
16870           }
16871           if (jjte000 instanceof RuntimeException) {
16872             {if (true) throw (RuntimeException)jjte000;}
16873           }
16874           if (jjte000 instanceof ParseException) {
16875             {if (true) throw (ParseException)jjte000;}
16876           }
16877           {if (true) throw (Error)jjte000;}
16878     } finally {
16879           if (jjtc000) {
16880             jjtree.closeNodeScope(jjtn000, true);
16881           }
16882     }
16883     throw new Error("Missing return statement in function");
16884   }
16885 
16886   final public ASTAssignment Assignment() throws ParseException {
16887  /*@bgen(jjtree) Assignment */
16888   ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
16889   boolean jjtc000 = true;
16890   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16891     try {
16892       simpleNode = PrimaryExpression();
16893                                        sb.append(simpleNode.getImage());
16894       jj_consume_token(9);
16895       jj_consume_token(10);
16896                sb.append(" := ");
16897       simpleNode = Expression();
16898                                sb.append(simpleNode.getImage());
16899    jjtree.closeNodeScope(jjtn000, true);
16900    jjtc000 = false;
16901  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16902     } catch (Throwable jjte000) {
16903     if (jjtc000) {
16904       jjtree.clearNodeScope(jjtn000);
16905       jjtc000 = false;
16906     } else {
16907       jjtree.popNode();
16908     }
16909     if (jjte000 instanceof RuntimeException) {
16910       {if (true) throw (RuntimeException)jjte000;}
16911     }
16912     if (jjte000 instanceof ParseException) {
16913       {if (true) throw (ParseException)jjte000;}
16914     }
16915     {if (true) throw (Error)jjte000;}
16916     } finally {
16917     if (jjtc000) {
16918       jjtree.closeNodeScope(jjtn000, true);
16919     }
16920     }
16921     throw new Error("Missing return statement in function");
16922   }
16923 
16924   final public ASTCaseExpression CaseExpression() throws ParseException {
16925  /*@bgen(jjtree) CaseExpression */
16926   ASTCaseExpression jjtn000 = new ASTCaseExpression(this, JJTCASEEXPRESSION);
16927   boolean jjtc000 = true;
16928   jjtree.openNodeScope(jjtn000);Token thisToken;  PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16929     try {
16930       thisToken = jj_consume_token(CASE);
16931                              sb.append(thisToken.image);
16932       switch (jj_nt.kind) {
16933       case 5:
16934       case 16:
16935       case 17:
16936       case REPLACE:
16937       case DEFINER:
16938       case CURRENT_USER:
16939       case LANGUAGE:
16940       case INLINE:
16941       case ADD:
16942       case AGGREGATE:
16943       case ARRAY:
16944       case AT:
16945       case ATTRIBUTE:
16946       case AUTHID:
16947       case BODY:
16948       case BULK:
16949       case BYTE:
16950       case CASCADE:
16951       case CASE:
16952       case CLOSE:
16953       case COALESCE:
16954       case COLLECT:
16955       case COLUMN:
16956       case COMMENT:
16957       case COMMIT:
16958       case CONSTRUCTOR:
16959       case CONTINUE:
16960       case CONVERT:
16961       case CURRENT:
16962       case CURSOR:
16963       case DATA:
16964       case DATE:
16965       case DAY:
16966       case DISABLE:
16967       case EDITIONABLE:
16968       case ELEMENT:
16969       case ENABLE:
16970       case ESCAPE:
16971       case EXCEPT:
16972       case EXCEPTIONS:
16973       case EXIT:
16974       case EXTERNAL:
16975       case EXTENDS:
16976       case EXTRACT:
16977       case FALSE:
16978       case FINAL:
16979       case FORCE:
16980       case FUNCTION:
16981       case GLOBAL:
16982       case HASH:
16983       case HEAP:
16984       case HOUR:
16985       case IMMEDIATE:
16986       case INDICES:
16987       case INDEXTYPE:
16988       case INDICATOR:
16989       case INSTANTIABLE:
16990       case INTERVAL:
16991       case INVALIDATE:
16992       case ISOLATION:
16993       case JAVA:
16994       case LEVEL:
16995       case LIMIT:
16996       case LOOP:
16997       case MAP:
16998       case MAX:
16999       case MEMBER:
17000       case MERGE:
17001       case MIN:
17002       case MINUTE:
17003       case MLSLABEL:
17004       case MODIFY:
17005       case MOD:
17006       case MONTH:
17007       case NATURAL:
17008       case NEW:
17009       case NEW_DOT:
17010       case NO:
17011       case NONEDITIONABLE:
17012       case NOT:
17013       case NULL:
17014       case NULLIF:
17015       case OBJECT:
17016       case OID:
17017       case OPAQUE:
17018       case OPEN:
17019       case OPERATOR:
17020       case ORGANIZATION:
17021       case OTHERS:
17022       case OVERRIDING:
17023       case PACKAGE:
17024       case PARTITION:
17025       case PRESERVE:
17026       case PRIVATE:
17027       case PROCEDURE:
17028       case RANGE:
17029       case RAW:
17030       case REAL:
17031       case RECORD:
17032       case REF:
17033       case RELEASE:
17034       case RELIES_ON:
17035       case RENAME:
17036       case RESULT:
17037       case RETURN:
17038       case RETURNING:
17039       case REVERSE:
17040       case ROLLBACK:
17041       case ROW:
17042       case ROWS:
17043       case ROWID:
17044       case ROWNUM:
17045       case SAVE:
17046       case SAVEPOINT:
17047       case SECOND:
17048       case SELECT:
17049       case SELF:
17050       case SET:
17051       case SPACE:
17052       case SQL:
17053       case SQLCODE:
17054       case SQLERRM:
17055       case STATIC:
17056       case SUBTYPE:
17057       case SUBSTITUTABLE:
17058       case SUCCESSFUL:
17059       case SYSDATE:
17060       case SYS_REFCURSOR:
17061       case TEMPORARY:
17062       case TIME:
17063       case TIMESTAMP:
17064       case TIMEZONE_REGION:
17065       case TIMEZONE_ABBR:
17066       case TIMEZONE_MINUTE:
17067       case TIMEZONE_HOUR:
17068       case TRANSACTION:
17069       case TRUE:
17070       case TYPE:
17071       case UNDER:
17072       case USING:
17073       case YES:
17074       case SHOW:
17075       case A:
17076       case DOUBLE:
17077       case DEC:
17078       case PRECISION:
17079       case INT:
17080       case NUMERIC:
17081       case NCHAR:
17082       case NVARCHAR2:
17083       case STRING:
17084       case UROWID:
17085       case VARRAY:
17086       case VARYING:
17087       case BFILE:
17088       case BLOB:
17089       case CLOB:
17090       case NCLOB:
17091       case YEAR:
17092       case LOCAL:
17093       case WITH:
17094       case ZONE:
17095       case CHARACTER:
17096       case AFTER:
17097       case BEFORE:
17098       case OLD:
17099       case PARENT:
17100       case CC_IF:
17101       case ANALYZE:
17102       case ASSOCIATE:
17103       case AUDIT:
17104       case COMPOUND:
17105       case DATABASE:
17106       case CALL:
17107       case DDL:
17108       case DISASSOCIATE:
17109       case EACH:
17110       case FOLLOWS:
17111       case LOGOFF:
17112       case LOGON:
17113       case NESTED:
17114       case NOAUDIT:
17115       case SCHEMA:
17116       case SERVERERROR:
17117       case SHUTDOWN:
17118       case STARTUP:
17119       case STATEMENT:
17120       case STATISTICS:
17121       case SUSPEND:
17122       case TRUNCATE:
17123       case WRAPPED:
17124       case LIBRARY:
17125       case NAME:
17126       case STRUCT:
17127       case CONTEXT:
17128       case PARAMETERS:
17129       case LENGTH:
17130       case TDO:
17131       case MAXLEN:
17132       case CHARSETID:
17133       case CHARSETFORM:
17134       case ACCEPT:
17135       case ACCESSIBLE:
17136       case COPY:
17137       case DEFINE:
17138       case DISCONNECT:
17139       case HOST:
17140       case PRINT:
17141       case QUIT:
17142       case REMARK:
17143       case UNDEFINE:
17144       case VARIABLE:
17145       case WHENEVER:
17146       case ATTACH:
17147       case CAST:
17148       case TREAT:
17149       case TRIM:
17150       case LEFT:
17151       case RIGHT:
17152       case BOTH:
17153       case EMPTY:
17154       case MULTISET:
17155       case SUBMULTISET:
17156       case LEADING:
17157       case TRAILING:
17158       case CHAR_CS:
17159       case NCHAR_CS:
17160       case DBTIMEZONE:
17161       case SESSIONTIMEZONE:
17162       case AUTHENTICATED:
17163       case LINK:
17164       case SHARED:
17165       case DIRECTORY:
17166       case USER:
17167       case IDENTIFIER:
17168       case UNSIGNED_NUMERIC_LITERAL:
17169       case CHARACTER_LITERAL:
17170       case STRING_LITERAL:
17171       case QUOTED_LITERAL:
17172         simpleNode = Expression();
17173                                       sb.append(" "); sb.append(simpleNode.getImage());
17174         break;
17175       default:
17176         jj_la1[216] = jj_gen;
17177         ;
17178       }
17179       label_51:
17180       while (true) {
17181         thisToken = jj_consume_token(WHEN);
17182                                  sb.append("  "); sb.append(thisToken.image);
17183         simpleNode = Expression();
17184                                             sb.append(" "); sb.append(simpleNode.getImage());
17185         thisToken = jj_consume_token(THEN);
17186                                    sb.append(" "); sb.append(thisToken.image);
17187         Expression();
17188                                  sb.append(" "); sb.append(simpleNode.getImage());
17189         switch (jj_nt.kind) {
17190         case WHEN:
17191           ;
17192           break;
17193         default:
17194           jj_la1[217] = jj_gen;
17195           break label_51;
17196         }
17197       }
17198       switch (jj_nt.kind) {
17199       case ELSE:
17200         thisToken = jj_consume_token(ELSE);
17201                                  sb.append(" "); sb.append(thisToken.image);
17202         Expression();
17203                                sb.append(" "); sb.append(simpleNode.getImage());
17204         break;
17205       default:
17206         jj_la1[218] = jj_gen;
17207         ;
17208       }
17209       thisToken = jj_consume_token(END);
17210                               sb.append(" "); sb.append(thisToken.image);
17211    jjtree.closeNodeScope(jjtn000, true);
17212    jjtc000 = false;
17213  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17214     } catch (Throwable jjte000) {
17215     if (jjtc000) {
17216       jjtree.clearNodeScope(jjtn000);
17217       jjtc000 = false;
17218     } else {
17219       jjtree.popNode();
17220     }
17221     if (jjte000 instanceof RuntimeException) {
17222       {if (true) throw (RuntimeException)jjte000;}
17223     }
17224     if (jjte000 instanceof ParseException) {
17225       {if (true) throw (ParseException)jjte000;}
17226     }
17227     {if (true) throw (Error)jjte000;}
17228     } finally {
17229     if (jjtc000) {
17230       jjtree.closeNodeScope(jjtn000, true);
17231     }
17232     }
17233     throw new Error("Missing return statement in function");
17234   }
17235 
17236 /*
17237 LIKE ( Expression ) [ <ESCAPE> <STRINGLITERAL>
17238 */
17239   final public ASTLikeExpression LikeExpression() throws ParseException {
17240  /*@bgen(jjtree) LikeExpression */
17241   ASTLikeExpression jjtn000 = new ASTLikeExpression(this, JJTLIKEEXPRESSION);
17242   boolean jjtc000 = true;
17243   jjtree.openNodeScope(jjtn000);Token thisToken;  PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17244     try {
17245       simpleNode = PrimaryExpression();
17246                                            sb.append(" "); sb.append(simpleNode.getImage());
17247       thisToken = jj_consume_token(LIKE);
17248                                 sb.append(thisToken.image);
17249       simpleNode = StringExpression();
17250                                             sb.append(" "); sb.append(simpleNode.getImage());
17251       switch (jj_nt.kind) {
17252       case ESCAPE:
17253         jj_consume_token(ESCAPE);
17254                    sb.append(" ESCAPE ");
17255         switch (jj_nt.kind) {
17256         case CHARACTER_LITERAL:
17257           jj_consume_token(CHARACTER_LITERAL);
17258                                 sb.append(" "); sb.append(token.toString());
17259           break;
17260         case STRING_LITERAL:
17261           simpleNode = StringLiteral();
17262                                            sb.append(" "); sb.append(simpleNode.getImage());
17263           break;
17264         default:
17265           jj_la1[219] = jj_gen;
17266           jj_consume_token(-1);
17267           throw new ParseException();
17268         }
17269         break;
17270       default:
17271         jj_la1[220] = jj_gen;
17272         ;
17273       }
17274       label_52:
17275       while (true) {
17276         switch (jj_nt.kind) {
17277         case 3:
17278           ;
17279           break;
17280         default:
17281           jj_la1[221] = jj_gen;
17282           break label_52;
17283         }
17284         jj_consume_token(3);
17285         simpleNode = Expression();
17286                                     sb.append("."); sb.append(simpleNode.getImage());
17287       }
17288    jjtree.closeNodeScope(jjtn000, true);
17289    jjtc000 = false;
17290  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17291     } catch (Throwable jjte000) {
17292     if (jjtc000) {
17293       jjtree.clearNodeScope(jjtn000);
17294       jjtc000 = false;
17295     } else {
17296       jjtree.popNode();
17297     }
17298     if (jjte000 instanceof RuntimeException) {
17299       {if (true) throw (RuntimeException)jjte000;}
17300     }
17301     if (jjte000 instanceof ParseException) {
17302       {if (true) throw (ParseException)jjte000;}
17303     }
17304     {if (true) throw (Error)jjte000;}
17305     } finally {
17306     if (jjtc000) {
17307       jjtree.closeNodeScope(jjtn000, true);
17308     }
17309     }
17310     throw new Error("Missing return statement in function");
17311   }
17312 
17313   final public ASTTrimExpression TrimExpression() throws ParseException {
17314  /*@bgen(jjtree) TrimExpression */
17315   ASTTrimExpression jjtn000 = new ASTTrimExpression(this, JJTTRIMEXPRESSION);
17316   boolean jjtc000 = true;
17317   jjtree.openNodeScope(jjtn000);Token thisToken;  PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17318     try {
17319       thisToken = jj_consume_token(TRIM);
17320                                 sb.append(thisToken.image);
17321       jj_consume_token(5);
17322               sb.append("(");
17323       switch (jj_nt.kind) {
17324       case BOTH:
17325       case LEADING:
17326       case TRAILING:
17327         switch (jj_nt.kind) {
17328         case LEADING:
17329           jj_consume_token(LEADING);
17330           break;
17331         case TRAILING:
17332           jj_consume_token(TRAILING);
17333           break;
17334         case BOTH:
17335           jj_consume_token(BOTH);
17336           break;
17337         default:
17338           jj_la1[222] = jj_gen;
17339           jj_consume_token(-1);
17340           throw new ParseException();
17341         }
17342                                                 sb.append(" "); sb.append(token.toString());
17343         break;
17344       default:
17345         jj_la1[223] = jj_gen;
17346         ;
17347       }
17348       switch (jj_nt.kind) {
17349       case 5:
17350       case REPLACE:
17351       case DEFINER:
17352       case CURRENT_USER:
17353       case LANGUAGE:
17354       case INLINE:
17355       case ADD:
17356       case AGGREGATE:
17357       case ARRAY:
17358       case AT:
17359       case ATTRIBUTE:
17360       case AUTHID:
17361       case BODY:
17362       case BULK:
17363       case BYTE:
17364       case CASCADE:
17365       case CASE:
17366       case CLOSE:
17367       case COALESCE:
17368       case COLLECT:
17369       case COLUMN:
17370       case COMMENT:
17371       case COMMIT:
17372       case CONSTRUCTOR:
17373       case CONTINUE:
17374       case CONVERT:
17375       case CURRENT:
17376       case CURSOR:
17377       case DATA:
17378       case DATE:
17379       case DAY:
17380       case DISABLE:
17381       case EDITIONABLE:
17382       case ELEMENT:
17383       case ENABLE:
17384       case ESCAPE:
17385       case EXCEPT:
17386       case EXCEPTIONS:
17387       case EXIT:
17388       case EXTERNAL:
17389       case EXTENDS:
17390       case EXTRACT:
17391       case FALSE:
17392       case FINAL:
17393       case FORCE:
17394       case FUNCTION:
17395       case GLOBAL:
17396       case HASH:
17397       case HEAP:
17398       case HOUR:
17399       case IMMEDIATE:
17400       case INDICES:
17401       case INDEXTYPE:
17402       case INDICATOR:
17403       case INSTANTIABLE:
17404       case INTERVAL:
17405       case INVALIDATE:
17406       case ISOLATION:
17407       case JAVA:
17408       case LEVEL:
17409       case LIMIT:
17410       case LOOP:
17411       case MAP:
17412       case MAX:
17413       case MEMBER:
17414       case MERGE:
17415       case MIN:
17416       case MINUTE:
17417       case MLSLABEL:
17418       case MODIFY:
17419       case MOD:
17420       case MONTH:
17421       case NATURAL:
17422       case NEW:
17423       case NEW_DOT:
17424       case NO:
17425       case NONEDITIONABLE:
17426       case NULL:
17427       case NULLIF:
17428       case OBJECT:
17429       case OID:
17430       case OPAQUE:
17431       case OPEN:
17432       case OPERATOR:
17433       case ORGANIZATION:
17434       case OTHERS:
17435       case OVERRIDING:
17436       case PACKAGE:
17437       case PARTITION:
17438       case PRESERVE:
17439       case PRIVATE:
17440       case PROCEDURE:
17441       case RANGE:
17442       case RAW:
17443       case REAL:
17444       case RECORD:
17445       case REF:
17446       case RELEASE:
17447       case RELIES_ON:
17448       case RENAME:
17449       case RESULT:
17450       case RETURN:
17451       case RETURNING:
17452       case REVERSE:
17453       case ROLLBACK:
17454       case ROW:
17455       case ROWS:
17456       case ROWID:
17457       case ROWNUM:
17458       case SAVE:
17459       case SAVEPOINT:
17460       case SECOND:
17461       case SELECT:
17462       case SELF:
17463       case SET:
17464       case SPACE:
17465       case SQL:
17466       case SQLCODE:
17467       case SQLERRM:
17468       case STATIC:
17469       case SUBTYPE:
17470       case SUBSTITUTABLE:
17471       case SUCCESSFUL:
17472       case SYSDATE:
17473       case SYS_REFCURSOR:
17474       case TEMPORARY:
17475       case TIME:
17476       case TIMESTAMP:
17477       case TIMEZONE_REGION:
17478       case TIMEZONE_ABBR:
17479       case TIMEZONE_MINUTE:
17480       case TIMEZONE_HOUR:
17481       case TRANSACTION:
17482       case TRUE:
17483       case TYPE:
17484       case UNDER:
17485       case USING:
17486       case YES:
17487       case SHOW:
17488       case A:
17489       case DOUBLE:
17490       case DEC:
17491       case PRECISION:
17492       case INT:
17493       case NUMERIC:
17494       case NCHAR:
17495       case NVARCHAR2:
17496       case STRING:
17497       case UROWID:
17498       case VARRAY:
17499       case VARYING:
17500       case BFILE:
17501       case BLOB:
17502       case CLOB:
17503       case NCLOB:
17504       case YEAR:
17505       case LOCAL:
17506       case WITH:
17507       case ZONE:
17508       case CHARACTER:
17509       case AFTER:
17510       case BEFORE:
17511       case OLD:
17512       case PARENT:
17513       case ANALYZE:
17514       case ASSOCIATE:
17515       case AUDIT:
17516       case COMPOUND:
17517       case DATABASE:
17518       case CALL:
17519       case DDL:
17520       case DISASSOCIATE:
17521       case EACH:
17522       case FOLLOWS:
17523       case LOGOFF:
17524       case LOGON:
17525       case NESTED:
17526       case NOAUDIT:
17527       case SCHEMA:
17528       case SERVERERROR:
17529       case SHUTDOWN:
17530       case STARTUP:
17531       case STATEMENT:
17532       case STATISTICS:
17533       case SUSPEND:
17534       case TRUNCATE:
17535       case WRAPPED:
17536       case LIBRARY:
17537       case NAME:
17538       case STRUCT:
17539       case CONTEXT:
17540       case PARAMETERS:
17541       case LENGTH:
17542       case TDO:
17543       case MAXLEN:
17544       case CHARSETID:
17545       case CHARSETFORM:
17546       case ACCEPT:
17547       case ACCESSIBLE:
17548       case COPY:
17549       case DEFINE:
17550       case DISCONNECT:
17551       case HOST:
17552       case PRINT:
17553       case QUIT:
17554       case REMARK:
17555       case UNDEFINE:
17556       case VARIABLE:
17557       case WHENEVER:
17558       case ATTACH:
17559       case CAST:
17560       case TREAT:
17561       case TRIM:
17562       case LEFT:
17563       case RIGHT:
17564       case BOTH:
17565       case EMPTY:
17566       case MULTISET:
17567       case SUBMULTISET:
17568       case LEADING:
17569       case TRAILING:
17570       case CHAR_CS:
17571       case NCHAR_CS:
17572       case DBTIMEZONE:
17573       case SESSIONTIMEZONE:
17574       case AUTHENTICATED:
17575       case LINK:
17576       case SHARED:
17577       case DIRECTORY:
17578       case USER:
17579       case IDENTIFIER:
17580       case UNSIGNED_NUMERIC_LITERAL:
17581       case CHARACTER_LITERAL:
17582       case STRING_LITERAL:
17583       case QUOTED_LITERAL:
17584         simpleNode = StringExpression();
17585                                              sb.append(" "); sb.append(simpleNode.getImage());
17586         break;
17587       default:
17588         jj_la1[224] = jj_gen;
17589         ;
17590       }
17591       jj_consume_token(FROM);
17592                         sb.append(thisToken.image);
17593       simpleNode = StringExpression();
17594                                            sb.append(" "); sb.append(simpleNode.getImage());
17595       jj_consume_token(7);
17596               sb.append(")");
17597    jjtree.closeNodeScope(jjtn000, true);
17598    jjtc000 = false;
17599  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17600     } catch (Throwable jjte000) {
17601     if (jjtc000) {
17602       jjtree.clearNodeScope(jjtn000);
17603       jjtc000 = false;
17604     } else {
17605       jjtree.popNode();
17606     }
17607     if (jjte000 instanceof RuntimeException) {
17608       {if (true) throw (RuntimeException)jjte000;}
17609     }
17610     if (jjte000 instanceof ParseException) {
17611       {if (true) throw (ParseException)jjte000;}
17612     }
17613     {if (true) throw (Error)jjte000;}
17614     } finally {
17615     if (jjtc000) {
17616       jjtree.closeNodeScope(jjtn000, true);
17617     }
17618     }
17619     throw new Error("Missing return statement in function");
17620   }
17621 
17622 /*
17623 TREAT ( Expression AS datatype)
17624 CAST ( Expression AS datatype)
17625 */
17626   final public ASTObjectExpression ObjectExpression() throws ParseException {
17627  /*@bgen(jjtree) ObjectExpression */
17628   ASTObjectExpression jjtn000 = new ASTObjectExpression(this, JJTOBJECTEXPRESSION);
17629   boolean jjtc000 = true;
17630   jjtree.openNodeScope(jjtn000);Token thisToken;  PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17631     try {
17632       switch (jj_nt.kind) {
17633       case CAST:
17634         thisToken = jj_consume_token(CAST);
17635         break;
17636       case TREAT:
17637         thisToken = jj_consume_token(TREAT);
17638         break;
17639       default:
17640         jj_la1[225] = jj_gen;
17641         jj_consume_token(-1);
17642         throw new ParseException();
17643       }
17644                                                       sb.append(thisToken.image);
17645       jj_consume_token(5);
17646               sb.append("(");
17647       simpleNode = Expression();
17648                                       sb.append(" "); sb.append(simpleNode.getImage());
17649       switch (jj_nt.kind) {
17650       case AT:
17651         jj_consume_token(AT);
17652         jj_consume_token(TIME);
17653         jj_consume_token(ZONE);
17654         simpleNode = PrimaryExpression();
17655                                                                sb.append(" AT TIME ZONE "); sb.append(simpleNode.getImage());
17656         break;
17657       default:
17658         jj_la1[226] = jj_gen;
17659         ;
17660       }
17661       jj_consume_token(AS);
17662                sb.append(" AS ");
17663       simpleNode = Datatype();
17664                                     sb.append(" "); sb.append(simpleNode.getImage());
17665       jj_consume_token(7);
17666               sb.append(")");
17667       label_53:
17668       while (true) {
17669         switch (jj_nt.kind) {
17670         case 3:
17671           ;
17672           break;
17673         default:
17674           jj_la1[227] = jj_gen;
17675           break label_53;
17676         }
17677         jj_consume_token(3);
17678         Expression();
17679       }
17680    jjtree.closeNodeScope(jjtn000, true);
17681    jjtc000 = false;
17682  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17683     } catch (Throwable jjte000) {
17684     if (jjtc000) {
17685       jjtree.clearNodeScope(jjtn000);
17686       jjtc000 = false;
17687     } else {
17688       jjtree.popNode();
17689     }
17690     if (jjte000 instanceof RuntimeException) {
17691       {if (true) throw (RuntimeException)jjte000;}
17692     }
17693     if (jjte000 instanceof ParseException) {
17694       {if (true) throw (ParseException)jjte000;}
17695     }
17696     {if (true) throw (Error)jjte000;}
17697     } finally {
17698     if (jjtc000) {
17699       jjtree.closeNodeScope(jjtn000, true);
17700     }
17701     }
17702     throw new Error("Missing return statement in function");
17703   }
17704 
17705   final public ASTConditionalOrExpression ConditionalOrExpression() throws ParseException {
17706  /*@bgen(jjtree) ConditionalOrExpression */
17707   ASTConditionalOrExpression jjtn000 = new ASTConditionalOrExpression(this, JJTCONDITIONALOREXPRESSION);
17708   boolean jjtc000 = true;
17709   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17710     try {
17711       simpleNode = ConditionalAndExpression();
17712                                                sb.append(simpleNode.getImage());
17713       label_54:
17714       while (true) {
17715         switch (jj_nt.kind) {
17716         case OR:
17717           ;
17718           break;
17719         default:
17720           jj_la1[228] = jj_gen;
17721           break label_54;
17722         }
17723         jj_consume_token(OR);
17724             sb.append(" OR ");
17725         simpleNode = ConditionalAndExpression();
17726                                                 sb.append(simpleNode.getImage());
17727       }
17728    jjtree.closeNodeScope(jjtn000, true);
17729    jjtc000 = false;
17730  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17731     } catch (Throwable jjte000) {
17732     if (jjtc000) {
17733       jjtree.clearNodeScope(jjtn000);
17734       jjtc000 = false;
17735     } else {
17736       jjtree.popNode();
17737     }
17738     if (jjte000 instanceof RuntimeException) {
17739       {if (true) throw (RuntimeException)jjte000;}
17740     }
17741     if (jjte000 instanceof ParseException) {
17742       {if (true) throw (ParseException)jjte000;}
17743     }
17744     {if (true) throw (Error)jjte000;}
17745     } finally {
17746     if (jjtc000) {
17747       jjtree.closeNodeScope(jjtn000, true);
17748     }
17749     }
17750     throw new Error("Missing return statement in function");
17751   }
17752 
17753   final public ASTConditionalAndExpression ConditionalAndExpression() throws ParseException {
17754  /*@bgen(jjtree) ConditionalAndExpression */
17755   ASTConditionalAndExpression jjtn000 = new ASTConditionalAndExpression(this, JJTCONDITIONALANDEXPRESSION);
17756   boolean jjtc000 = true;
17757   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17758     try {
17759       simpleNode = EqualityExpression();
17760                                           sb.append(simpleNode.getImage());
17761       label_55:
17762       while (true) {
17763         switch (jj_nt.kind) {
17764         case AND:
17765           ;
17766           break;
17767         default:
17768           jj_la1[229] = jj_gen;
17769           break label_55;
17770         }
17771         jj_consume_token(AND);
17772                sb.append(" AND ");
17773         simpleNode = EqualityExpression();
17774                                             sb.append(simpleNode.getImage());
17775       }
17776    jjtree.closeNodeScope(jjtn000, true);
17777    jjtc000 = false;
17778  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17779     } catch (Throwable jjte000) {
17780     if (jjtc000) {
17781       jjtree.clearNodeScope(jjtn000);
17782       jjtc000 = false;
17783     } else {
17784       jjtree.popNode();
17785     }
17786     if (jjte000 instanceof RuntimeException) {
17787       {if (true) throw (RuntimeException)jjte000;}
17788     }
17789     if (jjte000 instanceof ParseException) {
17790       {if (true) throw (ParseException)jjte000;}
17791     }
17792     {if (true) throw (Error)jjte000;}
17793     } finally {
17794     if (jjtc000) {
17795       jjtree.closeNodeScope(jjtn000, true);
17796     }
17797     }
17798     throw new Error("Missing return statement in function");
17799   }
17800 
17801   final public ASTEqualityExpression EqualityExpression() throws ParseException {
17802  /*@bgen(jjtree) EqualityExpression */
17803   ASTEqualityExpression jjtn000 = new ASTEqualityExpression(this, JJTEQUALITYEXPRESSION);
17804   boolean jjtc000 = true;
17805   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17806     try {
17807       simpleNode = RelationalExpression();
17808              sb.append(simpleNode.getImage());
17809       label_56:
17810       while (true) {
17811         switch (jj_nt.kind) {
17812         case 10:
17813         case 13:
17814         case IS:
17815           ;
17816           break;
17817         default:
17818           jj_la1[230] = jj_gen;
17819           break label_56;
17820         }
17821         switch (jj_nt.kind) {
17822         case 10:
17823           jj_consume_token(10);
17824                      sb.append(" = ");
17825           break;
17826         case 13:
17827           jj_consume_token(13);
17828           jj_consume_token(10);
17829                          sb.append(" != ");
17830           break;
17831         case IS:
17832           jj_consume_token(IS);
17833                      sb.append(" IS ");
17834           break;
17835         default:
17836           jj_la1[231] = jj_gen;
17837           jj_consume_token(-1);
17838           throw new ParseException();
17839         }
17840         simpleNode = RelationalExpression();
17841               sb.append(simpleNode.getImage());
17842       }
17843    jjtree.closeNodeScope(jjtn000, true);
17844    jjtc000 = false;
17845  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17846     } catch (Throwable jjte000) {
17847     if (jjtc000) {
17848       jjtree.clearNodeScope(jjtn000);
17849       jjtc000 = false;
17850     } else {
17851       jjtree.popNode();
17852     }
17853     if (jjte000 instanceof RuntimeException) {
17854       {if (true) throw (RuntimeException)jjte000;}
17855     }
17856     if (jjte000 instanceof ParseException) {
17857       {if (true) throw (ParseException)jjte000;}
17858     }
17859     {if (true) throw (Error)jjte000;}
17860     } finally {
17861     if (jjtc000) {
17862       jjtree.closeNodeScope(jjtn000, true);
17863     }
17864     }
17865     throw new Error("Missing return statement in function");
17866   }
17867 
17868 /**
17869  * 2006-05-23 - Matthias Hendler - added FROM
17870  */
17871   final public ASTRelationalExpression RelationalExpression() throws ParseException {
17872  /*@bgen(jjtree) RelationalExpression */
17873   ASTRelationalExpression jjtn000 = new ASTRelationalExpression(this, JJTRELATIONALEXPRESSION);
17874   boolean jjtc000 = true;
17875   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17876     try {
17877       simpleNode = AdditiveExpression();
17878                                          sb.append(simpleNode.getImage());
17879       label_57:
17880       while (true) {
17881         switch (jj_nt.kind) {
17882         case 14:
17883         case 15:
17884         case BETWEEN:
17885         case FROM:
17886         case IN:
17887         case LIKE:
17888         case MEMBER:
17889         case NOT:
17890         case MULTISET:
17891         case SUBMULTISET:
17892           ;
17893           break;
17894         default:
17895           jj_la1[232] = jj_gen;
17896           break label_57;
17897         }
17898         switch (jj_nt.kind) {
17899         case 14:
17900         case 15:
17901           switch (jj_nt.kind) {
17902           case 14:
17903             jj_consume_token(14);
17904                       sb.append("<");
17905             switch (jj_nt.kind) {
17906             case 15:
17907               jj_consume_token(15);
17908                      sb.append(">");
17909               break;
17910             default:
17911               jj_la1[233] = jj_gen;
17912               ;
17913             }
17914             break;
17915           case 15:
17916             jj_consume_token(15);
17917                      sb.append(">");
17918             break;
17919           default:
17920             jj_la1[234] = jj_gen;
17921             jj_consume_token(-1);
17922             throw new ParseException();
17923           }
17924           switch (jj_nt.kind) {
17925           case 10:
17926             jj_consume_token(10);
17927                    sb.append("=");
17928             break;
17929           default:
17930             jj_la1[235] = jj_gen;
17931             ;
17932           }
17933         sb.append(" ");
17934           break;
17935         case BETWEEN:
17936         case FROM:
17937         case IN:
17938         case LIKE:
17939         case MEMBER:
17940         case NOT:
17941         case SUBMULTISET:
17942           switch (jj_nt.kind) {
17943           case NOT:
17944             jj_consume_token(NOT);
17945                 sb.append(" NOT ");
17946             break;
17947           default:
17948             jj_la1[236] = jj_gen;
17949             ;
17950           }
17951           switch (jj_nt.kind) {
17952           case IN:
17953             jj_consume_token(IN);
17954                sb.append(" IN ");
17955             break;
17956           case BETWEEN:
17957             jj_consume_token(BETWEEN);
17958                       sb.append(" BETWEEN ");
17959             break;
17960           case LIKE:
17961             jj_consume_token(LIKE);
17962                    sb.append(" LIKE ");
17963             break;
17964           case FROM:
17965             jj_consume_token(FROM);
17966                   sb.append(" FROM ");
17967             break;
17968           case MEMBER:
17969           case SUBMULTISET:
17970             switch (jj_nt.kind) {
17971             case MEMBER:
17972               jj_consume_token(MEMBER);
17973                         sb.append(" MEMBER ");
17974               break;
17975             case SUBMULTISET:
17976               jj_consume_token(SUBMULTISET);
17977                              sb.append(" SUBMULTISET ");
17978               break;
17979             default:
17980               jj_la1[237] = jj_gen;
17981               jj_consume_token(-1);
17982               throw new ParseException();
17983             }
17984             switch (jj_nt.kind) {
17985             case OF:
17986               jj_consume_token(OF);
17987                   sb.append(" OF ");
17988               break;
17989             default:
17990               jj_la1[238] = jj_gen;
17991               ;
17992             }
17993             break;
17994           default:
17995             jj_la1[239] = jj_gen;
17996             jj_consume_token(-1);
17997             throw new ParseException();
17998           }
17999           break;
18000         case MULTISET:
18001           jj_consume_token(MULTISET);
18002                     sb.append (" MULTISET " );
18003           switch (jj_nt.kind) {
18004           case EXCEPT:
18005             jj_consume_token(EXCEPT);
18006                        sb.append (" EXCEPT " );
18007             break;
18008           case INTERSECT:
18009             jj_consume_token(INTERSECT);
18010                           sb.append (" INTERSECT " );
18011             break;
18012           case UNION:
18013             jj_consume_token(UNION);
18014                       sb.append (" UNION " );
18015             break;
18016           default:
18017             jj_la1[240] = jj_gen;
18018             jj_consume_token(-1);
18019             throw new ParseException();
18020           }
18021           switch (jj_nt.kind) {
18022           case ALL:
18023           case DISTINCT:
18024             switch (jj_nt.kind) {
18025             case DISTINCT:
18026               jj_consume_token(DISTINCT);
18027                          sb.append (" DISTINCT " );
18028               break;
18029             case ALL:
18030               jj_consume_token(ALL);
18031                     sb.append (" ALL " );
18032               break;
18033             default:
18034               jj_la1[241] = jj_gen;
18035               jj_consume_token(-1);
18036               throw new ParseException();
18037             }
18038             break;
18039           default:
18040             jj_la1[242] = jj_gen;
18041             ;
18042           }
18043           break;
18044         default:
18045           jj_la1[243] = jj_gen;
18046           jj_consume_token(-1);
18047           throw new ParseException();
18048         }
18049         AdditiveExpression();
18050                              sb.append(simpleNode.getImage());
18051         switch (jj_nt.kind) {
18052         case ESCAPE:
18053           jj_consume_token(ESCAPE);
18054                    sb.append(" ESCAPE ");
18055           switch (jj_nt.kind) {
18056           case CHARACTER_LITERAL:
18057             jj_consume_token(CHARACTER_LITERAL);
18058                                 sb.append(" "); sb.append(token.toString());
18059             break;
18060           case STRING_LITERAL:
18061             simpleNode = StringLiteral();
18062                                            sb.append(" "); sb.append(simpleNode.getImage());
18063             break;
18064           default:
18065             jj_la1[244] = jj_gen;
18066             jj_consume_token(-1);
18067             throw new ParseException();
18068           }
18069           break;
18070         default:
18071           jj_la1[245] = jj_gen;
18072           ;
18073         }
18074       }
18075    jjtree.closeNodeScope(jjtn000, true);
18076    jjtc000 = false;
18077  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18078     } catch (Throwable jjte000) {
18079    if (jjtc000) {
18080      jjtree.clearNodeScope(jjtn000);
18081      jjtc000 = false;
18082    } else {
18083      jjtree.popNode();
18084    }
18085    if (jjte000 instanceof RuntimeException) {
18086      {if (true) throw (RuntimeException)jjte000;}
18087    }
18088    if (jjte000 instanceof ParseException) {
18089      {if (true) throw (ParseException)jjte000;}
18090    }
18091    {if (true) throw (Error)jjte000;}
18092     } finally {
18093    if (jjtc000) {
18094      jjtree.closeNodeScope(jjtn000, true);
18095    }
18096     }
18097     throw new Error("Missing return statement in function");
18098   }
18099 
18100   final public ASTAdditiveExpression AdditiveExpression() throws ParseException {
18101  /*@bgen(jjtree) AdditiveExpression */
18102   ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(this, JJTADDITIVEEXPRESSION);
18103   boolean jjtc000 = true;
18104   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18105     try {
18106       simpleNode = MultiplicativeExpression();
18107                                                sb.append(simpleNode.getImage());
18108       label_58:
18109       while (true) {
18110         switch (jj_nt.kind) {
18111         case 16:
18112         case 17:
18113         case 18:
18114           ;
18115           break;
18116         default:
18117           jj_la1[246] = jj_gen;
18118           break label_58;
18119         }
18120         switch (jj_nt.kind) {
18121         case 16:
18122           jj_consume_token(16);
18123                sb.append(" + ");
18124           break;
18125         case 17:
18126           jj_consume_token(17);
18127                sb.append(" - ");
18128           break;
18129         case 18:
18130           jj_consume_token(18);
18131                 sb.append(" || ");
18132           break;
18133         default:
18134           jj_la1[247] = jj_gen;
18135           jj_consume_token(-1);
18136           throw new ParseException();
18137         }
18138         simpleNode = MultiplicativeExpression();
18139                                                  sb.append(simpleNode.getImage());
18140       }
18141    jjtree.closeNodeScope(jjtn000, true);
18142    jjtc000 = false;
18143  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18144     } catch (Throwable jjte000) {
18145    if (jjtc000) {
18146      jjtree.clearNodeScope(jjtn000);
18147      jjtc000 = false;
18148    } else {
18149      jjtree.popNode();
18150    }
18151    if (jjte000 instanceof RuntimeException) {
18152      {if (true) throw (RuntimeException)jjte000;}
18153    }
18154    if (jjte000 instanceof ParseException) {
18155      {if (true) throw (ParseException)jjte000;}
18156    }
18157    {if (true) throw (Error)jjte000;}
18158     } finally {
18159    if (jjtc000) {
18160      jjtree.closeNodeScope(jjtn000, true);
18161    }
18162     }
18163     throw new Error("Missing return statement in function");
18164   }
18165 
18166   final public ASTStringExpression StringExpression() throws ParseException {
18167  /*@bgen(jjtree) StringExpression */
18168   ASTStringExpression jjtn000 = new ASTStringExpression(this, JJTSTRINGEXPRESSION);
18169   boolean jjtc000 = true;
18170   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18171     try {
18172       simpleNode = PrimaryExpression();
18173                                         sb.append(simpleNode.getImage());
18174       label_59:
18175       while (true) {
18176         switch (jj_nt.kind) {
18177         case 18:
18178           ;
18179           break;
18180         default:
18181           jj_la1[248] = jj_gen;
18182           break label_59;
18183         }
18184         jj_consume_token(18);
18185                sb.append(" || ");
18186         simpleNode = PrimaryExpression();
18187                                           sb.append(simpleNode.getImage());
18188       }
18189    jjtree.closeNodeScope(jjtn000, true);
18190    jjtc000 = false;
18191  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18192     } catch (Throwable jjte000) {
18193    if (jjtc000) {
18194      jjtree.clearNodeScope(jjtn000);
18195      jjtc000 = false;
18196    } else {
18197      jjtree.popNode();
18198    }
18199    if (jjte000 instanceof RuntimeException) {
18200      {if (true) throw (RuntimeException)jjte000;}
18201    }
18202    if (jjte000 instanceof ParseException) {
18203      {if (true) throw (ParseException)jjte000;}
18204    }
18205    {if (true) throw (Error)jjte000;}
18206     } finally {
18207    if (jjtc000) {
18208      jjtree.closeNodeScope(jjtn000, true);
18209    }
18210     }
18211     throw new Error("Missing return statement in function");
18212   }
18213 
18214   final public ASTMultiplicativeExpression MultiplicativeExpression() throws ParseException {
18215  /*@bgen(jjtree) MultiplicativeExpression */
18216   ASTMultiplicativeExpression jjtn000 = new ASTMultiplicativeExpression(this, JJTMULTIPLICATIVEEXPRESSION);
18217   boolean jjtc000 = true;
18218   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18219     try {
18220       simpleNode = UnaryExpression(true);
18221                                           sb.append(simpleNode.getImage());
18222       label_60:
18223       while (true) {
18224         switch (jj_nt.kind) {
18225         case 1:
18226         case 19:
18227         case 20:
18228         case MOD:
18229           ;
18230           break;
18231         default:
18232           jj_la1[249] = jj_gen;
18233           break label_60;
18234         }
18235         switch (jj_nt.kind) {
18236         case 19:
18237           jj_consume_token(19);
18238                  sb.append(" ** ");
18239           break;
18240         case 20:
18241           jj_consume_token(20);
18242                 sb.append(" * ");
18243           break;
18244         case 1:
18245           jj_consume_token(1);
18246                 sb.append(" / ");
18247           break;
18248         case MOD:
18249           jj_consume_token(MOD);
18250                   sb.append(" MOD ");
18251           break;
18252         default:
18253           jj_la1[250] = jj_gen;
18254           jj_consume_token(-1);
18255           throw new ParseException();
18256         }
18257         simpleNode = UnaryExpression(true);
18258                                             sb.append(simpleNode.getImage());
18259       }
18260    jjtree.closeNodeScope(jjtn000, true);
18261    jjtc000 = false;
18262  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18263     } catch (Throwable jjte000) {
18264    if (jjtc000) {
18265      jjtree.clearNodeScope(jjtn000);
18266      jjtc000 = false;
18267    } else {
18268      jjtree.popNode();
18269    }
18270    if (jjte000 instanceof RuntimeException) {
18271      {if (true) throw (RuntimeException)jjte000;}
18272    }
18273    if (jjte000 instanceof ParseException) {
18274      {if (true) throw (ParseException)jjte000;}
18275    }
18276    {if (true) throw (Error)jjte000;}
18277     } finally {
18278    if (jjtc000) {
18279      jjtree.closeNodeScope(jjtn000, true);
18280    }
18281     }
18282     throw new Error("Missing return statement in function");
18283   }
18284 
18285   final public ASTUnaryExpression UnaryExpression(boolean isUnarySign) throws ParseException {
18286  /*@bgen(jjtree) UnaryExpression */
18287   ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION);
18288   boolean jjtc000 = true;
18289   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18290     try {
18291       switch (jj_nt.kind) {
18292       case 16:
18293       case 17:
18294         switch (jj_nt.kind) {
18295         case 16:
18296           jj_consume_token(16);
18297               sb.append(isUnarySign ? " +" : " + ");
18298           break;
18299         case 17:
18300           jj_consume_token(17);
18301               sb.append(isUnarySign ? " -" : " - ");
18302           break;
18303         default:
18304           jj_la1[251] = jj_gen;
18305           jj_consume_token(-1);
18306           throw new ParseException();
18307         }
18308         simpleNode = UnaryExpression(false);
18309                                             sb.append(simpleNode.getImage());
18310         break;
18311       case 5:
18312       case REPLACE:
18313       case DEFINER:
18314       case CURRENT_USER:
18315       case LANGUAGE:
18316       case INLINE:
18317       case ADD:
18318       case AGGREGATE:
18319       case ARRAY:
18320       case AT:
18321       case ATTRIBUTE:
18322       case AUTHID:
18323       case BODY:
18324       case BULK:
18325       case BYTE:
18326       case CASCADE:
18327       case CASE:
18328       case CLOSE:
18329       case COALESCE:
18330       case COLLECT:
18331       case COLUMN:
18332       case COMMENT:
18333       case COMMIT:
18334       case CONSTRUCTOR:
18335       case CONTINUE:
18336       case CONVERT:
18337       case CURRENT:
18338       case CURSOR:
18339       case DATA:
18340       case DATE:
18341       case DAY:
18342       case DISABLE:
18343       case EDITIONABLE:
18344       case ELEMENT:
18345       case ENABLE:
18346       case ESCAPE:
18347       case EXCEPT:
18348       case EXCEPTIONS:
18349       case EXIT:
18350       case EXTERNAL:
18351       case EXTENDS:
18352       case EXTRACT:
18353       case FALSE:
18354       case FINAL:
18355       case FORCE:
18356       case FUNCTION:
18357       case GLOBAL:
18358       case HASH:
18359       case HEAP:
18360       case HOUR:
18361       case IMMEDIATE:
18362       case INDICES:
18363       case INDEXTYPE:
18364       case INDICATOR:
18365       case INSTANTIABLE:
18366       case INTERVAL:
18367       case INVALIDATE:
18368       case ISOLATION:
18369       case JAVA:
18370       case LEVEL:
18371       case LIMIT:
18372       case LOOP:
18373       case MAP:
18374       case MAX:
18375       case MEMBER:
18376       case MERGE:
18377       case MIN:
18378       case MINUTE:
18379       case MLSLABEL:
18380       case MODIFY:
18381       case MOD:
18382       case MONTH:
18383       case NATURAL:
18384       case NEW:
18385       case NEW_DOT:
18386       case NO:
18387       case NONEDITIONABLE:
18388       case NOT:
18389       case NULL:
18390       case NULLIF:
18391       case OBJECT:
18392       case OID:
18393       case OPAQUE:
18394       case OPEN:
18395       case OPERATOR:
18396       case ORGANIZATION:
18397       case OTHERS:
18398       case OVERRIDING:
18399       case PACKAGE:
18400       case PARTITION:
18401       case PRESERVE:
18402       case PRIVATE:
18403       case PROCEDURE:
18404       case RANGE:
18405       case RAW:
18406       case REAL:
18407       case RECORD:
18408       case REF:
18409       case RELEASE:
18410       case RELIES_ON:
18411       case RENAME:
18412       case RESULT:
18413       case RETURN:
18414       case RETURNING:
18415       case REVERSE:
18416       case ROLLBACK:
18417       case ROW:
18418       case ROWS:
18419       case ROWID:
18420       case ROWNUM:
18421       case SAVE:
18422       case SAVEPOINT:
18423       case SECOND:
18424       case SELECT:
18425       case SELF:
18426       case SET:
18427       case SPACE:
18428       case SQL:
18429       case SQLCODE:
18430       case SQLERRM:
18431       case STATIC:
18432       case SUBTYPE:
18433       case SUBSTITUTABLE:
18434       case SUCCESSFUL:
18435       case SYSDATE:
18436       case SYS_REFCURSOR:
18437       case TEMPORARY:
18438       case TIME:
18439       case TIMESTAMP:
18440       case TIMEZONE_REGION:
18441       case TIMEZONE_ABBR:
18442       case TIMEZONE_MINUTE:
18443       case TIMEZONE_HOUR:
18444       case TRANSACTION:
18445       case TRUE:
18446       case TYPE:
18447       case UNDER:
18448       case USING:
18449       case YES:
18450       case SHOW:
18451       case A:
18452       case DOUBLE:
18453       case DEC:
18454       case PRECISION:
18455       case INT:
18456       case NUMERIC:
18457       case NCHAR:
18458       case NVARCHAR2:
18459       case STRING:
18460       case UROWID:
18461       case VARRAY:
18462       case VARYING:
18463       case BFILE:
18464       case BLOB:
18465       case CLOB:
18466       case NCLOB:
18467       case YEAR:
18468       case LOCAL:
18469       case WITH:
18470       case ZONE:
18471       case CHARACTER:
18472       case AFTER:
18473       case BEFORE:
18474       case OLD:
18475       case PARENT:
18476       case ANALYZE:
18477       case ASSOCIATE:
18478       case AUDIT:
18479       case COMPOUND:
18480       case DATABASE:
18481       case CALL:
18482       case DDL:
18483       case DISASSOCIATE:
18484       case EACH:
18485       case FOLLOWS:
18486       case LOGOFF:
18487       case LOGON:
18488       case NESTED:
18489       case NOAUDIT:
18490       case SCHEMA:
18491       case SERVERERROR:
18492       case SHUTDOWN:
18493       case STARTUP:
18494       case STATEMENT:
18495       case STATISTICS:
18496       case SUSPEND:
18497       case TRUNCATE:
18498       case WRAPPED:
18499       case LIBRARY:
18500       case NAME:
18501       case STRUCT:
18502       case CONTEXT:
18503       case PARAMETERS:
18504       case LENGTH:
18505       case TDO:
18506       case MAXLEN:
18507       case CHARSETID:
18508       case CHARSETFORM:
18509       case ACCEPT:
18510       case ACCESSIBLE:
18511       case COPY:
18512       case DEFINE:
18513       case DISCONNECT:
18514       case HOST:
18515       case PRINT:
18516       case QUIT:
18517       case REMARK:
18518       case UNDEFINE:
18519       case VARIABLE:
18520       case WHENEVER:
18521       case ATTACH:
18522       case CAST:
18523       case TREAT:
18524       case TRIM:
18525       case LEFT:
18526       case RIGHT:
18527       case BOTH:
18528       case EMPTY:
18529       case MULTISET:
18530       case SUBMULTISET:
18531       case LEADING:
18532       case TRAILING:
18533       case CHAR_CS:
18534       case NCHAR_CS:
18535       case DBTIMEZONE:
18536       case SESSIONTIMEZONE:
18537       case AUTHENTICATED:
18538       case LINK:
18539       case SHARED:
18540       case DIRECTORY:
18541       case USER:
18542       case IDENTIFIER:
18543       case UNSIGNED_NUMERIC_LITERAL:
18544       case CHARACTER_LITERAL:
18545       case STRING_LITERAL:
18546       case QUOTED_LITERAL:
18547         simpleNode = UnaryExpressionNotPlusMinus();
18548                                                    sb.append(simpleNode.getImage());
18549         break;
18550       default:
18551         jj_la1[252] = jj_gen;
18552         jj_consume_token(-1);
18553         throw new ParseException();
18554       }
18555    jjtree.closeNodeScope(jjtn000, true);
18556    jjtc000 = false;
18557  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18558     } catch (Throwable jjte000) {
18559    if (jjtc000) {
18560      jjtree.clearNodeScope(jjtn000);
18561      jjtc000 = false;
18562    } else {
18563      jjtree.popNode();
18564    }
18565    if (jjte000 instanceof RuntimeException) {
18566      {if (true) throw (RuntimeException)jjte000;}
18567    }
18568    if (jjte000 instanceof ParseException) {
18569      {if (true) throw (ParseException)jjte000;}
18570    }
18571    {if (true) throw (Error)jjte000;}
18572     } finally {
18573    if (jjtc000) {
18574      jjtree.closeNodeScope(jjtn000, true);
18575    }
18576     }
18577     throw new Error("Missing return statement in function");
18578   }
18579 
18580   final public ASTUnaryExpressionNotPlusMinus UnaryExpressionNotPlusMinus() throws ParseException {
18581  /*@bgen(jjtree) UnaryExpressionNotPlusMinus */
18582   ASTUnaryExpressionNotPlusMinus jjtn000 = new ASTUnaryExpressionNotPlusMinus(this, JJTUNARYEXPRESSIONNOTPLUSMINUS);
18583   boolean jjtc000 = true;
18584   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18585     try {
18586       switch (jj_nt.kind) {
18587       case NOT:
18588         jj_consume_token(NOT);
18589            sb.append(" NOT ");
18590         simpleNode = UnaryExpression(false);
18591                                            sb.append(simpleNode.getImage());
18592         break;
18593       case 5:
18594       case REPLACE:
18595       case DEFINER:
18596       case CURRENT_USER:
18597       case LANGUAGE:
18598       case INLINE:
18599       case ADD:
18600       case AGGREGATE:
18601       case ARRAY:
18602       case AT:
18603       case ATTRIBUTE:
18604       case AUTHID:
18605       case BODY:
18606       case BULK:
18607       case BYTE:
18608       case CASCADE:
18609       case CASE:
18610       case CLOSE:
18611       case COALESCE:
18612       case COLLECT:
18613       case COLUMN:
18614       case COMMENT:
18615       case COMMIT:
18616       case CONSTRUCTOR:
18617       case CONTINUE:
18618       case CONVERT:
18619       case CURRENT:
18620       case CURSOR:
18621       case DATA:
18622       case DATE:
18623       case DAY:
18624       case DISABLE:
18625       case EDITIONABLE:
18626       case ELEMENT:
18627       case ENABLE:
18628       case ESCAPE:
18629       case EXCEPT:
18630       case EXCEPTIONS:
18631       case EXIT:
18632       case EXTERNAL:
18633       case EXTENDS:
18634       case EXTRACT:
18635       case FALSE:
18636       case FINAL:
18637       case FORCE:
18638       case FUNCTION:
18639       case GLOBAL:
18640       case HASH:
18641       case HEAP:
18642       case HOUR:
18643       case IMMEDIATE:
18644       case INDICES:
18645       case INDEXTYPE:
18646       case INDICATOR:
18647       case INSTANTIABLE:
18648       case INTERVAL:
18649       case INVALIDATE:
18650       case ISOLATION:
18651       case JAVA:
18652       case LEVEL:
18653       case LIMIT:
18654       case LOOP:
18655       case MAP:
18656       case MAX:
18657       case MEMBER:
18658       case MERGE:
18659       case MIN:
18660       case MINUTE:
18661       case MLSLABEL:
18662       case MODIFY:
18663       case MOD:
18664       case MONTH:
18665       case NATURAL:
18666       case NEW:
18667       case NEW_DOT:
18668       case NO:
18669       case NONEDITIONABLE:
18670       case NULL:
18671       case NULLIF:
18672       case OBJECT:
18673       case OID:
18674       case OPAQUE:
18675       case OPEN:
18676       case OPERATOR:
18677       case ORGANIZATION:
18678       case OTHERS:
18679       case OVERRIDING:
18680       case PACKAGE:
18681       case PARTITION:
18682       case PRESERVE:
18683       case PRIVATE:
18684       case PROCEDURE:
18685       case RANGE:
18686       case RAW:
18687       case REAL:
18688       case RECORD:
18689       case REF:
18690       case RELEASE:
18691       case RELIES_ON:
18692       case RENAME:
18693       case RESULT:
18694       case RETURN:
18695       case RETURNING:
18696       case REVERSE:
18697       case ROLLBACK:
18698       case ROW:
18699       case ROWS:
18700       case ROWID:
18701       case ROWNUM:
18702       case SAVE:
18703       case SAVEPOINT:
18704       case SECOND:
18705       case SELECT:
18706       case SELF:
18707       case SET:
18708       case SPACE:
18709       case SQL:
18710       case SQLCODE:
18711       case SQLERRM:
18712       case STATIC:
18713       case SUBTYPE:
18714       case SUBSTITUTABLE:
18715       case SUCCESSFUL:
18716       case SYSDATE:
18717       case SYS_REFCURSOR:
18718       case TEMPORARY:
18719       case TIME:
18720       case TIMESTAMP:
18721       case TIMEZONE_REGION:
18722       case TIMEZONE_ABBR:
18723       case TIMEZONE_MINUTE:
18724       case TIMEZONE_HOUR:
18725       case TRANSACTION:
18726       case TRUE:
18727       case TYPE:
18728       case UNDER:
18729       case USING:
18730       case YES:
18731       case SHOW:
18732       case A:
18733       case DOUBLE:
18734       case DEC:
18735       case PRECISION:
18736       case INT:
18737       case NUMERIC:
18738       case NCHAR:
18739       case NVARCHAR2:
18740       case STRING:
18741       case UROWID:
18742       case VARRAY:
18743       case VARYING:
18744       case BFILE:
18745       case BLOB:
18746       case CLOB:
18747       case NCLOB:
18748       case YEAR:
18749       case LOCAL:
18750       case WITH:
18751       case ZONE:
18752       case CHARACTER:
18753       case AFTER:
18754       case BEFORE:
18755       case OLD:
18756       case PARENT:
18757       case ANALYZE:
18758       case ASSOCIATE:
18759       case AUDIT:
18760       case COMPOUND:
18761       case DATABASE:
18762       case CALL:
18763       case DDL:
18764       case DISASSOCIATE:
18765       case EACH:
18766       case FOLLOWS:
18767       case LOGOFF:
18768       case LOGON:
18769       case NESTED:
18770       case NOAUDIT:
18771       case SCHEMA:
18772       case SERVERERROR:
18773       case SHUTDOWN:
18774       case STARTUP:
18775       case STATEMENT:
18776       case STATISTICS:
18777       case SUSPEND:
18778       case TRUNCATE:
18779       case WRAPPED:
18780       case LIBRARY:
18781       case NAME:
18782       case STRUCT:
18783       case CONTEXT:
18784       case PARAMETERS:
18785       case LENGTH:
18786       case TDO:
18787       case MAXLEN:
18788       case CHARSETID:
18789       case CHARSETFORM:
18790       case ACCEPT:
18791       case ACCESSIBLE:
18792       case COPY:
18793       case DEFINE:
18794       case DISCONNECT:
18795       case HOST:
18796       case PRINT:
18797       case QUIT:
18798       case REMARK:
18799       case UNDEFINE:
18800       case VARIABLE:
18801       case WHENEVER:
18802       case ATTACH:
18803       case CAST:
18804       case TREAT:
18805       case TRIM:
18806       case LEFT:
18807       case RIGHT:
18808       case BOTH:
18809       case EMPTY:
18810       case MULTISET:
18811       case SUBMULTISET:
18812       case LEADING:
18813       case TRAILING:
18814       case CHAR_CS:
18815       case NCHAR_CS:
18816       case DBTIMEZONE:
18817       case SESSIONTIMEZONE:
18818       case AUTHENTICATED:
18819       case LINK:
18820       case SHARED:
18821       case DIRECTORY:
18822       case USER:
18823       case IDENTIFIER:
18824       case UNSIGNED_NUMERIC_LITERAL:
18825       case CHARACTER_LITERAL:
18826       case STRING_LITERAL:
18827       case QUOTED_LITERAL:
18828         simpleNode = IsOfTypeCondition();
18829                                         sb.append(simpleNode.getImage());
18830         break;
18831       default:
18832         jj_la1[253] = jj_gen;
18833         jj_consume_token(-1);
18834         throw new ParseException();
18835       }
18836    jjtree.closeNodeScope(jjtn000, true);
18837    jjtc000 = false;
18838  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18839     } catch (Throwable jjte000) {
18840     if (jjtc000) {
18841       jjtree.clearNodeScope(jjtn000);
18842       jjtc000 = false;
18843     } else {
18844       jjtree.popNode();
18845     }
18846     if (jjte000 instanceof RuntimeException) {
18847       {if (true) throw (RuntimeException)jjte000;}
18848     }
18849     if (jjte000 instanceof ParseException) {
18850       {if (true) throw (ParseException)jjte000;}
18851     }
18852     {if (true) throw (Error)jjte000;}
18853     } finally {
18854     if (jjtc000) {
18855       jjtree.closeNodeScope(jjtn000, true);
18856     }
18857     }
18858     throw new Error("Missing return statement in function");
18859   }
18860 
18861   final public ASTIsOfTypeCondition IsOfTypeCondition() throws ParseException {
18862  /*@bgen(jjtree) IsOfTypeCondition */
18863   ASTIsOfTypeCondition jjtn000 = new ASTIsOfTypeCondition(this, JJTISOFTYPECONDITION);
18864   boolean jjtc000 = true;
18865   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; PLSQLNode name = null; StringBuilder sb = new StringBuilder();
18866     try {
18867       if (jj_2_46(2147483647)) {
18868         name = Name();
18869                       sb.append(name.getImage());
18870         jj_consume_token(IS);
18871                                                          sb.append(" IS");
18872         switch (jj_nt.kind) {
18873         case NOT:
18874           jj_consume_token(NOT);
18875                                                                                     sb.append(" NOT");
18876           break;
18877         default:
18878           jj_la1[254] = jj_gen;
18879           ;
18880         }
18881         jj_consume_token(OF);
18882                                                                                                                sb.append(" OF");
18883         switch (jj_nt.kind) {
18884         case TYPE:
18885           jj_consume_token(TYPE);
18886           break;
18887         default:
18888           jj_la1[255] = jj_gen;
18889           ;
18890         }
18891         jj_consume_token(5);
18892         switch (jj_nt.kind) {
18893         case ONLY:
18894           jj_consume_token(ONLY);
18895           break;
18896         default:
18897           jj_la1[256] = jj_gen;
18898           ;
18899         }
18900         Name();
18901         label_61:
18902         while (true) {
18903           switch (jj_nt.kind) {
18904           case 6:
18905             ;
18906             break;
18907           default:
18908             jj_la1[257] = jj_gen;
18909             break label_61;
18910           }
18911           jj_consume_token(6);
18912           switch (jj_nt.kind) {
18913           case ONLY:
18914             jj_consume_token(ONLY);
18915             break;
18916           default:
18917             jj_la1[258] = jj_gen;
18918             ;
18919           }
18920           Name();
18921         }
18922         jj_consume_token(7);
18923       } else {
18924         switch (jj_nt.kind) {
18925         case 5:
18926         case REPLACE:
18927         case DEFINER:
18928         case CURRENT_USER:
18929         case LANGUAGE:
18930         case INLINE:
18931         case ADD:
18932         case AGGREGATE:
18933         case ARRAY:
18934         case AT:
18935         case ATTRIBUTE:
18936         case AUTHID:
18937         case BODY:
18938         case BULK:
18939         case BYTE:
18940         case CASCADE:
18941         case CASE:
18942         case CLOSE:
18943         case COALESCE:
18944         case COLLECT:
18945         case COLUMN:
18946         case COMMENT:
18947         case COMMIT:
18948         case CONSTRUCTOR:
18949         case CONTINUE:
18950         case CONVERT:
18951         case CURRENT:
18952         case CURSOR:
18953         case DATA:
18954         case DATE:
18955         case DAY:
18956         case DISABLE:
18957         case EDITIONABLE:
18958         case ELEMENT:
18959         case ENABLE:
18960         case ESCAPE:
18961         case EXCEPT:
18962         case EXCEPTIONS:
18963         case EXIT:
18964         case EXTERNAL:
18965         case EXTENDS:
18966         case EXTRACT:
18967         case FALSE:
18968         case FINAL:
18969         case FORCE:
18970         case FUNCTION:
18971         case GLOBAL:
18972         case HASH:
18973         case HEAP:
18974         case HOUR:
18975         case IMMEDIATE:
18976         case INDICES:
18977         case INDEXTYPE:
18978         case INDICATOR:
18979         case INSTANTIABLE:
18980         case INTERVAL:
18981         case INVALIDATE:
18982         case ISOLATION:
18983         case JAVA:
18984         case LEVEL:
18985         case LIMIT:
18986         case LOOP:
18987         case MAP:
18988         case MAX:
18989         case MEMBER:
18990         case MERGE:
18991         case MIN:
18992         case MINUTE:
18993         case MLSLABEL:
18994         case MODIFY:
18995         case MOD:
18996         case MONTH:
18997         case NATURAL:
18998         case NEW:
18999         case NEW_DOT:
19000         case NO:
19001         case NONEDITIONABLE:
19002         case NULL:
19003         case NULLIF:
19004         case OBJECT:
19005         case OID:
19006         case OPAQUE:
19007         case OPEN:
19008         case OPERATOR:
19009         case ORGANIZATION:
19010         case OTHERS:
19011         case OVERRIDING:
19012         case PACKAGE:
19013         case PARTITION:
19014         case PRESERVE:
19015         case PRIVATE:
19016         case PROCEDURE:
19017         case RANGE:
19018         case RAW:
19019         case REAL:
19020         case RECORD:
19021         case REF:
19022         case RELEASE:
19023         case RELIES_ON:
19024         case RENAME:
19025         case RESULT:
19026         case RETURN:
19027         case RETURNING:
19028         case REVERSE:
19029         case ROLLBACK:
19030         case ROW:
19031         case ROWS:
19032         case ROWID:
19033         case ROWNUM:
19034         case SAVE:
19035         case SAVEPOINT:
19036         case SECOND:
19037         case SELECT:
19038         case SELF:
19039         case SET:
19040         case SPACE:
19041         case SQL:
19042         case SQLCODE:
19043         case SQLERRM:
19044         case STATIC:
19045         case SUBTYPE:
19046         case SUBSTITUTABLE:
19047         case SUCCESSFUL:
19048         case SYSDATE:
19049         case SYS_REFCURSOR:
19050         case TEMPORARY:
19051         case TIME:
19052         case TIMESTAMP:
19053         case TIMEZONE_REGION:
19054         case TIMEZONE_ABBR:
19055         case TIMEZONE_MINUTE:
19056         case TIMEZONE_HOUR:
19057         case TRANSACTION:
19058         case TRUE:
19059         case TYPE:
19060         case UNDER:
19061         case USING:
19062         case YES:
19063         case SHOW:
19064         case A:
19065         case DOUBLE:
19066         case DEC:
19067         case PRECISION:
19068         case INT:
19069         case NUMERIC:
19070         case NCHAR:
19071         case NVARCHAR2:
19072         case STRING:
19073         case UROWID:
19074         case VARRAY:
19075         case VARYING:
19076         case BFILE:
19077         case BLOB:
19078         case CLOB:
19079         case NCLOB:
19080         case YEAR:
19081         case LOCAL:
19082         case WITH:
19083         case ZONE:
19084         case CHARACTER:
19085         case AFTER:
19086         case BEFORE:
19087         case OLD:
19088         case PARENT:
19089         case ANALYZE:
19090         case ASSOCIATE:
19091         case AUDIT:
19092         case COMPOUND:
19093         case DATABASE:
19094         case CALL:
19095         case DDL:
19096         case DISASSOCIATE:
19097         case EACH:
19098         case FOLLOWS:
19099         case LOGOFF:
19100         case LOGON:
19101         case NESTED:
19102         case NOAUDIT:
19103         case SCHEMA:
19104         case SERVERERROR:
19105         case SHUTDOWN:
19106         case STARTUP:
19107         case STATEMENT:
19108         case STATISTICS:
19109         case SUSPEND:
19110         case TRUNCATE:
19111         case WRAPPED:
19112         case LIBRARY:
19113         case NAME:
19114         case STRUCT:
19115         case CONTEXT:
19116         case PARAMETERS:
19117         case LENGTH:
19118         case TDO:
19119         case MAXLEN:
19120         case CHARSETID:
19121         case CHARSETFORM:
19122         case ACCEPT:
19123         case ACCESSIBLE:
19124         case COPY:
19125         case DEFINE:
19126         case DISCONNECT:
19127         case HOST:
19128         case PRINT:
19129         case QUIT:
19130         case REMARK:
19131         case UNDEFINE:
19132         case VARIABLE:
19133         case WHENEVER:
19134         case ATTACH:
19135         case CAST:
19136         case TREAT:
19137         case TRIM:
19138         case LEFT:
19139         case RIGHT:
19140         case BOTH:
19141         case EMPTY:
19142         case MULTISET:
19143         case SUBMULTISET:
19144         case LEADING:
19145         case TRAILING:
19146         case CHAR_CS:
19147         case NCHAR_CS:
19148         case DBTIMEZONE:
19149         case SESSIONTIMEZONE:
19150         case AUTHENTICATED:
19151         case LINK:
19152         case SHARED:
19153         case DIRECTORY:
19154         case USER:
19155         case IDENTIFIER:
19156         case UNSIGNED_NUMERIC_LITERAL:
19157         case CHARACTER_LITERAL:
19158         case STRING_LITERAL:
19159         case QUOTED_LITERAL:
19160           simpleNode = PrimaryExpression();
19161                                           sb.append(simpleNode.getImage());
19162           break;
19163         default:
19164           jj_la1[259] = jj_gen;
19165           jj_consume_token(-1);
19166           throw new ParseException();
19167         }
19168       }
19169     jjtree.closeNodeScope(jjtn000, true);
19170     jjtc000 = false;
19171     jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
19172     } catch (Throwable jjte000) {
19173     if (jjtc000) {
19174       jjtree.clearNodeScope(jjtn000);
19175       jjtc000 = false;
19176     } else {
19177       jjtree.popNode();
19178     }
19179     if (jjte000 instanceof RuntimeException) {
19180       {if (true) throw (RuntimeException)jjte000;}
19181     }
19182     if (jjte000 instanceof ParseException) {
19183       {if (true) throw (ParseException)jjte000;}
19184     }
19185     {if (true) throw (Error)jjte000;}
19186     } finally {
19187     if (jjtc000) {
19188       jjtree.closeNodeScope(jjtn000, true);
19189     }
19190     }
19191     throw new Error("Missing return statement in function");
19192   }
19193 
19194 /**
19195  * 2006-05-23 - Matthias Hendler - Added lookahead otherwise warning encountered.
19196  *                                 Warning arised while adding methode triggerUnit(). 
19197  * 2011-04-27 - SRT - Add optional NEW Keyword to cope with Object Type constructors
19198  */
19199   final public ASTPrimaryExpression PrimaryExpression() throws ParseException {
19200  /*@bgen(jjtree) PrimaryExpression */
19201   ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION);
19202   boolean jjtc000 = true;
19203   jjtree.openNodeScope(jjtn000);Token thisToken ; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
19204     try {
19205       switch (jj_nt.kind) {
19206       case NEW_DOT:
19207         jj_consume_token(NEW_DOT);
19208         simpleNode = QualifiedID();
19209                                                        sb.append(" NEW."); sb.append(simpleNode.getImage());
19210         break;
19211       case 5:
19212       case REPLACE:
19213       case DEFINER:
19214       case CURRENT_USER:
19215       case LANGUAGE:
19216       case INLINE:
19217       case ADD:
19218       case AGGREGATE:
19219       case ARRAY:
19220       case AT:
19221       case ATTRIBUTE:
19222       case AUTHID:
19223       case BODY:
19224       case BULK:
19225       case BYTE:
19226       case CASCADE:
19227       case CASE:
19228       case CLOSE:
19229       case COALESCE:
19230       case COLLECT:
19231       case COLUMN:
19232       case COMMENT:
19233       case COMMIT:
19234       case CONSTRUCTOR:
19235       case CONTINUE:
19236       case CONVERT:
19237       case CURRENT:
19238       case CURSOR:
19239       case DATA:
19240       case DATE:
19241       case DAY:
19242       case DISABLE:
19243       case EDITIONABLE:
19244       case ELEMENT:
19245       case ENABLE:
19246       case ESCAPE:
19247       case EXCEPT:
19248       case EXCEPTIONS:
19249       case EXIT:
19250       case EXTERNAL:
19251       case EXTENDS:
19252       case EXTRACT:
19253       case FALSE:
19254       case FINAL:
19255       case FORCE:
19256       case FUNCTION:
19257       case GLOBAL:
19258       case HASH:
19259       case HEAP:
19260       case HOUR:
19261       case IMMEDIATE:
19262       case INDICES:
19263       case INDEXTYPE:
19264       case INDICATOR:
19265       case INSTANTIABLE:
19266       case INTERVAL:
19267       case INVALIDATE:
19268       case ISOLATION:
19269       case JAVA:
19270       case LEVEL:
19271       case LIMIT:
19272       case LOOP:
19273       case MAP:
19274       case MAX:
19275       case MEMBER:
19276       case MERGE:
19277       case MIN:
19278       case MINUTE:
19279       case MLSLABEL:
19280       case MODIFY:
19281       case MOD:
19282       case MONTH:
19283       case NATURAL:
19284       case NEW:
19285       case NO:
19286       case NONEDITIONABLE:
19287       case NULL:
19288       case NULLIF:
19289       case OBJECT:
19290       case OID:
19291       case OPAQUE:
19292       case OPEN:
19293       case OPERATOR:
19294       case ORGANIZATION:
19295       case OTHERS:
19296       case OVERRIDING:
19297       case PACKAGE:
19298       case PARTITION:
19299       case PRESERVE:
19300       case PRIVATE:
19301       case PROCEDURE:
19302       case RANGE:
19303       case RAW:
19304       case REAL:
19305       case RECORD:
19306       case REF:
19307       case RELEASE:
19308       case RELIES_ON:
19309       case RENAME:
19310       case RESULT:
19311       case RETURN:
19312       case RETURNING:
19313       case REVERSE:
19314       case ROLLBACK:
19315       case ROW:
19316       case ROWS:
19317       case ROWID:
19318       case ROWNUM:
19319       case SAVE:
19320       case SAVEPOINT:
19321       case SECOND:
19322       case SELECT:
19323       case SELF:
19324       case SET:
19325       case SPACE:
19326       case SQL:
19327       case SQLCODE:
19328       case SQLERRM:
19329       case STATIC:
19330       case SUBTYPE:
19331       case SUBSTITUTABLE:
19332       case SUCCESSFUL:
19333       case SYSDATE:
19334       case SYS_REFCURSOR:
19335       case TEMPORARY:
19336       case TIME:
19337       case TIMESTAMP:
19338       case TIMEZONE_REGION:
19339       case TIMEZONE_ABBR:
19340       case TIMEZONE_MINUTE:
19341       case TIMEZONE_HOUR:
19342       case TRANSACTION:
19343       case TRUE:
19344       case TYPE:
19345       case UNDER:
19346       case USING:
19347       case YES:
19348       case SHOW:
19349       case A:
19350       case DOUBLE:
19351       case DEC:
19352       case PRECISION:
19353       case INT:
19354       case NUMERIC:
19355       case NCHAR:
19356       case NVARCHAR2:
19357       case STRING:
19358       case UROWID:
19359       case VARRAY:
19360       case VARYING:
19361       case BFILE:
19362       case BLOB:
19363       case CLOB:
19364       case NCLOB:
19365       case YEAR:
19366       case LOCAL:
19367       case WITH:
19368       case ZONE:
19369       case CHARACTER:
19370       case AFTER:
19371       case BEFORE:
19372       case OLD:
19373       case PARENT:
19374       case ANALYZE:
19375       case ASSOCIATE:
19376       case AUDIT:
19377       case COMPOUND:
19378       case DATABASE:
19379       case CALL:
19380       case DDL:
19381       case DISASSOCIATE:
19382       case EACH:
19383       case FOLLOWS:
19384       case LOGOFF:
19385       case LOGON:
19386       case NESTED:
19387       case NOAUDIT:
19388       case SCHEMA:
19389       case SERVERERROR:
19390       case SHUTDOWN:
19391       case STARTUP:
19392       case STATEMENT:
19393       case STATISTICS:
19394       case SUSPEND:
19395       case TRUNCATE:
19396       case WRAPPED:
19397       case LIBRARY:
19398       case NAME:
19399       case STRUCT:
19400       case CONTEXT:
19401       case PARAMETERS:
19402       case LENGTH:
19403       case TDO:
19404       case MAXLEN:
19405       case CHARSETID:
19406       case CHARSETFORM:
19407       case ACCEPT:
19408       case ACCESSIBLE:
19409       case COPY:
19410       case DEFINE:
19411       case DISCONNECT:
19412       case HOST:
19413       case PRINT:
19414       case QUIT:
19415       case REMARK:
19416       case UNDEFINE:
19417       case VARIABLE:
19418       case WHENEVER:
19419       case ATTACH:
19420       case CAST:
19421       case TREAT:
19422       case TRIM:
19423       case LEFT:
19424       case RIGHT:
19425       case BOTH:
19426       case EMPTY:
19427       case MULTISET:
19428       case SUBMULTISET:
19429       case LEADING:
19430       case TRAILING:
19431       case CHAR_CS:
19432       case NCHAR_CS:
19433       case DBTIMEZONE:
19434       case SESSIONTIMEZONE:
19435       case AUTHENTICATED:
19436       case LINK:
19437       case SHARED:
19438       case DIRECTORY:
19439       case USER:
19440       case IDENTIFIER:
19441       case UNSIGNED_NUMERIC_LITERAL:
19442       case CHARACTER_LITERAL:
19443       case STRING_LITERAL:
19444       case QUOTED_LITERAL:
19445         if (jj_2_47(2147483647)) {
19446           jj_consume_token(NEW);
19447                 sb.append(" NEW ");
19448           simpleNode = PrimaryPrefix();
19449                                                                        sb.append(simpleNode.getImage());
19450         } else {
19451           switch (jj_nt.kind) {
19452           case 5:
19453           case REPLACE:
19454           case DEFINER:
19455           case CURRENT_USER:
19456           case LANGUAGE:
19457           case INLINE:
19458           case ADD:
19459           case AGGREGATE:
19460           case ARRAY:
19461           case AT:
19462           case ATTRIBUTE:
19463           case AUTHID:
19464           case BODY:
19465           case BULK:
19466           case BYTE:
19467           case CASCADE:
19468           case CASE:
19469           case CLOSE:
19470           case COALESCE:
19471           case COLLECT:
19472           case COLUMN:
19473           case COMMENT:
19474           case COMMIT:
19475           case CONSTRUCTOR:
19476           case CONTINUE:
19477           case CONVERT:
19478           case CURRENT:
19479           case CURSOR:
19480           case DATA:
19481           case DATE:
19482           case DAY:
19483           case DISABLE:
19484           case EDITIONABLE:
19485           case ELEMENT:
19486           case ENABLE:
19487           case ESCAPE:
19488           case EXCEPT:
19489           case EXCEPTIONS:
19490           case EXIT:
19491           case EXTERNAL:
19492           case EXTENDS:
19493           case EXTRACT:
19494           case FALSE:
19495           case FINAL:
19496           case FORCE:
19497           case FUNCTION:
19498           case GLOBAL:
19499           case HASH:
19500           case HEAP:
19501           case HOUR:
19502           case IMMEDIATE:
19503           case INDICES:
19504           case INDEXTYPE:
19505           case INDICATOR:
19506           case INSTANTIABLE:
19507           case INTERVAL:
19508           case INVALIDATE:
19509           case ISOLATION:
19510           case JAVA:
19511           case LEVEL:
19512           case LIMIT:
19513           case LOOP:
19514           case MAP:
19515           case MAX:
19516           case MEMBER:
19517           case MERGE:
19518           case MIN:
19519           case MINUTE:
19520           case MLSLABEL:
19521           case MODIFY:
19522           case MOD:
19523           case MONTH:
19524           case NATURAL:
19525           case NEW:
19526           case NO:
19527           case NONEDITIONABLE:
19528           case NULL:
19529           case NULLIF:
19530           case OBJECT:
19531           case OID:
19532           case OPAQUE:
19533           case OPEN:
19534           case OPERATOR:
19535           case ORGANIZATION:
19536           case OTHERS:
19537           case OVERRIDING:
19538           case PACKAGE:
19539           case PARTITION:
19540           case PRESERVE:
19541           case PRIVATE:
19542           case PROCEDURE:
19543           case RANGE:
19544           case RAW:
19545           case REAL:
19546           case RECORD:
19547           case REF:
19548           case RELEASE:
19549           case RELIES_ON:
19550           case RENAME:
19551           case RESULT:
19552           case RETURN:
19553           case RETURNING:
19554           case REVERSE:
19555           case ROLLBACK:
19556           case ROW:
19557           case ROWS:
19558           case ROWID:
19559           case ROWNUM:
19560           case SAVE:
19561           case SAVEPOINT:
19562           case SECOND:
19563           case SELECT:
19564           case SELF:
19565           case SET:
19566           case SPACE:
19567           case SQL:
19568           case SQLCODE:
19569           case SQLERRM:
19570           case STATIC:
19571           case SUBTYPE:
19572           case SUBSTITUTABLE:
19573           case SUCCESSFUL:
19574           case SYSDATE:
19575           case SYS_REFCURSOR:
19576           case TEMPORARY:
19577           case TIME:
19578           case TIMESTAMP:
19579           case TIMEZONE_REGION:
19580           case TIMEZONE_ABBR:
19581           case TIMEZONE_MINUTE:
19582           case TIMEZONE_HOUR:
19583           case TRANSACTION:
19584           case TRUE:
19585           case TYPE:
19586           case UNDER:
19587           case USING:
19588           case YES:
19589           case SHOW:
19590           case A:
19591           case DOUBLE:
19592           case DEC:
19593           case PRECISION:
19594           case INT:
19595           case NUMERIC:
19596           case NCHAR:
19597           case NVARCHAR2:
19598           case STRING:
19599           case UROWID:
19600           case VARRAY:
19601           case VARYING:
19602           case BFILE:
19603           case BLOB:
19604           case CLOB:
19605           case NCLOB:
19606           case YEAR:
19607           case LOCAL:
19608           case WITH:
19609           case ZONE:
19610           case CHARACTER:
19611           case AFTER:
19612           case BEFORE:
19613           case OLD:
19614           case PARENT:
19615           case ANALYZE:
19616           case ASSOCIATE:
19617           case AUDIT:
19618           case COMPOUND:
19619           case DATABASE:
19620           case CALL:
19621           case DDL:
19622           case DISASSOCIATE:
19623           case EACH:
19624           case FOLLOWS:
19625           case LOGOFF:
19626           case LOGON:
19627           case NESTED:
19628           case NOAUDIT:
19629           case SCHEMA:
19630           case SERVERERROR:
19631           case SHUTDOWN:
19632           case STARTUP:
19633           case STATEMENT:
19634           case STATISTICS:
19635           case SUSPEND:
19636           case TRUNCATE:
19637           case WRAPPED:
19638           case LIBRARY:
19639           case NAME:
19640           case STRUCT:
19641           case CONTEXT:
19642           case PARAMETERS:
19643           case LENGTH:
19644           case TDO:
19645           case MAXLEN:
19646           case CHARSETID:
19647           case CHARSETFORM:
19648           case ACCEPT:
19649           case ACCESSIBLE:
19650           case COPY:
19651           case DEFINE:
19652           case DISCONNECT:
19653           case HOST:
19654           case PRINT:
19655           case QUIT:
19656           case REMARK:
19657           case UNDEFINE:
19658           case VARIABLE:
19659           case WHENEVER:
19660           case ATTACH:
19661           case CAST:
19662           case TREAT:
19663           case TRIM:
19664           case LEFT:
19665           case RIGHT:
19666           case BOTH:
19667           case EMPTY:
19668           case MULTISET:
19669           case SUBMULTISET:
19670           case LEADING:
19671           case TRAILING:
19672           case CHAR_CS:
19673           case NCHAR_CS:
19674           case DBTIMEZONE:
19675           case SESSIONTIMEZONE:
19676           case AUTHENTICATED:
19677           case LINK:
19678           case SHARED:
19679           case DIRECTORY:
19680           case USER:
19681           case IDENTIFIER:
19682           case UNSIGNED_NUMERIC_LITERAL:
19683           case CHARACTER_LITERAL:
19684           case STRING_LITERAL:
19685           case QUOTED_LITERAL:
19686             simpleNode = PrimaryPrefix();
19687                                                sb.append(simpleNode.getImage());
19688             break;
19689           default:
19690             jj_la1[260] = jj_gen;
19691             jj_consume_token(-1);
19692             throw new ParseException();
19693           }
19694         }
19695         label_62:
19696         while (true) {
19697           if (jj_2_48(2)) {
19698             ;
19699           } else {
19700             break label_62;
19701           }
19702           simpleNode = PrimarySuffix();
19703                                                            sb.append(simpleNode.getImage());
19704         }
19705         break;
19706       default:
19707         jj_la1[261] = jj_gen;
19708         jj_consume_token(-1);
19709         throw new ParseException();
19710       }
19711    jjtree.closeNodeScope(jjtn000, true);
19712    jjtc000 = false;
19713  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
19714     } catch (Throwable jjte000) {
19715     if (jjtc000) {
19716       jjtree.clearNodeScope(jjtn000);
19717       jjtc000 = false;
19718     } else {
19719       jjtree.popNode();
19720     }
19721     if (jjte000 instanceof RuntimeException) {
19722       {if (true) throw (RuntimeException)jjte000;}
19723     }
19724     if (jjte000 instanceof ParseException) {
19725       {if (true) throw (ParseException)jjte000;}
19726     }
19727     {if (true) throw (Error)jjte000;}
19728     } finally {
19729     if (jjtc000) {
19730       jjtree.closeNodeScope(jjtn000, true);
19731     }
19732     }
19733     throw new Error("Missing return statement in function");
19734   }
19735 
19736   final public ASTPrimaryPrefix PrimaryPrefix() throws ParseException {
19737  /*@bgen(jjtree) PrimaryPrefix */
19738   ASTPrimaryPrefix jjtn000 = new ASTPrimaryPrefix(this, JJTPRIMARYPREFIX);
19739   boolean jjtc000 = true;
19740   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
19741     try {
19742       switch (jj_nt.kind) {
19743       case DATE:
19744       case FALSE:
19745       case INTERVAL:
19746       case NULL:
19747       case TIMESTAMP:
19748       case TRUE:
19749       case UNSIGNED_NUMERIC_LITERAL:
19750       case CHARACTER_LITERAL:
19751       case STRING_LITERAL:
19752         simpleNode = Literal();
19753                                sb.append(simpleNode.getImage()) ;
19754         break;
19755       default:
19756         jj_la1[263] = jj_gen;
19757         if (jj_2_49(2147483647)) {
19758           simpleNode = MultiSetCondition();
19759         } else if (jj_2_50(2147483647)) {
19760           simpleNode = TrimExpression();
19761         } else if (jj_2_51(2147483647)) {
19762           simpleNode = CaseExpression();
19763                                                                  sb.append(simpleNode.getImage()) ;
19764         } else if (jj_2_52(2147483647)) {
19765           simpleNode = ObjectExpression();
19766                                                                        sb.append(simpleNode.getImage()) ;
19767         } else {
19768           switch (jj_nt.kind) {
19769           case REPLACE:
19770           case DEFINER:
19771           case CURRENT_USER:
19772           case LANGUAGE:
19773           case INLINE:
19774           case ADD:
19775           case AGGREGATE:
19776           case ARRAY:
19777           case AT:
19778           case ATTRIBUTE:
19779           case AUTHID:
19780           case BODY:
19781           case BULK:
19782           case BYTE:
19783           case CASCADE:
19784           case CLOSE:
19785           case COALESCE:
19786           case COLLECT:
19787           case COLUMN:
19788           case COMMENT:
19789           case COMMIT:
19790           case CONSTRUCTOR:
19791           case CONTINUE:
19792           case CONVERT:
19793           case CURRENT:
19794           case CURSOR:
19795           case DATA:
19796           case DAY:
19797           case DISABLE:
19798           case EDITIONABLE:
19799           case ELEMENT:
19800           case ENABLE:
19801           case ESCAPE:
19802           case EXCEPT:
19803           case EXCEPTIONS:
19804           case EXIT:
19805           case EXTERNAL:
19806           case EXTENDS:
19807           case EXTRACT:
19808           case FALSE:
19809           case FINAL:
19810           case FORCE:
19811           case FUNCTION:
19812           case GLOBAL:
19813           case HASH:
19814           case HEAP:
19815           case HOUR:
19816           case IMMEDIATE:
19817           case INDICES:
19818           case INDEXTYPE:
19819           case INDICATOR:
19820           case INSTANTIABLE:
19821           case INTERVAL:
19822           case INVALIDATE:
19823           case ISOLATION:
19824           case JAVA:
19825           case LEVEL:
19826           case LIMIT:
19827           case LOOP:
19828           case MAP:
19829           case MAX:
19830           case MEMBER:
19831           case MERGE:
19832           case MIN:
19833           case MINUTE:
19834           case MLSLABEL:
19835           case MODIFY:
19836           case MOD:
19837           case MONTH:
19838           case NATURAL:
19839           case NEW:
19840           case NO:
19841           case NONEDITIONABLE:
19842           case NULLIF:
19843           case OBJECT:
19844           case OID:
19845           case OPAQUE:
19846           case OPEN:
19847           case OPERATOR:
19848           case ORGANIZATION:
19849           case OTHERS:
19850           case OVERRIDING:
19851           case PACKAGE:
19852           case PARTITION:
19853           case PRESERVE:
19854           case PRIVATE:
19855           case PROCEDURE:
19856           case RANGE:
19857           case RAW:
19858           case REAL:
19859           case RECORD:
19860           case REF:
19861           case RELEASE:
19862           case RELIES_ON:
19863           case RENAME:
19864           case RESULT:
19865           case RETURN:
19866           case RETURNING:
19867           case REVERSE:
19868           case ROLLBACK:
19869           case ROW:
19870           case ROWS:
19871           case ROWID:
19872           case ROWNUM:
19873           case SAVE:
19874           case SAVEPOINT:
19875           case SECOND:
19876           case SELF:
19877           case SET:
19878           case SPACE:
19879           case SQL:
19880           case SQLCODE:
19881           case SQLERRM:
19882           case STATIC:
19883           case SUBTYPE:
19884           case SUBSTITUTABLE:
19885           case SUCCESSFUL:
19886           case SYSDATE:
19887           case SYS_REFCURSOR:
19888           case TEMPORARY:
19889           case TIME:
19890           case TIMESTAMP:
19891           case TIMEZONE_REGION:
19892           case TIMEZONE_ABBR:
19893           case TIMEZONE_MINUTE:
19894           case TIMEZONE_HOUR:
19895           case TRANSACTION:
19896           case TRUE:
19897           case TYPE:
19898           case UNDER:
19899           case USING:
19900           case YES:
19901           case SHOW:
19902           case A:
19903           case DOUBLE:
19904           case DEC:
19905           case PRECISION:
19906           case INT:
19907           case NUMERIC:
19908           case NCHAR:
19909           case NVARCHAR2:
19910           case STRING:
19911           case UROWID:
19912           case VARRAY:
19913           case VARYING:
19914           case BFILE:
19915           case BLOB:
19916           case CLOB:
19917           case NCLOB:
19918           case YEAR:
19919           case LOCAL:
19920           case ZONE:
19921           case CHARACTER:
19922           case AFTER:
19923           case BEFORE:
19924           case OLD:
19925           case PARENT:
19926           case ANALYZE:
19927           case ASSOCIATE:
19928           case AUDIT:
19929           case COMPOUND:
19930           case DATABASE:
19931           case CALL:
19932           case DDL:
19933           case DISASSOCIATE:
19934           case EACH:
19935           case FOLLOWS:
19936           case LOGOFF:
19937           case LOGON:
19938           case NESTED:
19939           case NOAUDIT:
19940           case SCHEMA:
19941           case SERVERERROR:
19942           case SHUTDOWN:
19943           case STARTUP:
19944           case STATEMENT:
19945           case STATISTICS:
19946           case SUSPEND:
19947           case TRUNCATE:
19948           case WRAPPED:
19949           case LIBRARY:
19950           case NAME:
19951           case STRUCT:
19952           case CONTEXT:
19953           case PARAMETERS:
19954           case LENGTH:
19955           case TDO:
19956           case MAXLEN:
19957           case CHARSETID:
19958           case CHARSETFORM:
19959           case ACCEPT:
19960           case ACCESSIBLE:
19961           case COPY:
19962           case DEFINE:
19963           case DISCONNECT:
19964           case HOST:
19965           case PRINT:
19966           case QUIT:
19967           case REMARK:
19968           case UNDEFINE:
19969           case VARIABLE:
19970           case WHENEVER:
19971           case ATTACH:
19972           case CAST:
19973           case TREAT:
19974           case TRIM:
19975           case LEFT:
19976           case RIGHT:
19977           case BOTH:
19978           case EMPTY:
19979           case MULTISET:
19980           case SUBMULTISET:
19981           case LEADING:
19982           case TRAILING:
19983           case CHAR_CS:
19984           case NCHAR_CS:
19985           case DBTIMEZONE:
19986           case SESSIONTIMEZONE:
19987           case AUTHENTICATED:
19988           case LINK:
19989           case SHARED:
19990           case DIRECTORY:
19991           case USER:
19992           case IDENTIFIER:
19993           case QUOTED_LITERAL:
19994             simpleNode = Name();
19995                            sb.append(simpleNode.getImage()) ;
19996             break;
19997           default:
19998             jj_la1[264] = jj_gen;
19999             if (jj_2_53(2147483647)) {
20000               jj_consume_token(SELECT);
20001                                   sb.append("SELECT ...");
20002               Skip2NextTerminator(null,";");
20003             } else if (jj_2_54(2147483647)) {
20004               jj_consume_token(5);
20005                                     sb.append("(SELECT ...");
20006               Skip2NextTerminator("(",")");
20007               jj_consume_token(7);
20008             } else if (jj_2_55(2147483647)) {
20009               jj_consume_token(WITH);
20010                               sb.append("WITH ...");
20011               Skip2NextTerminator(null,";");
20012             } else if (jj_2_56(2147483647)) {
20013               jj_consume_token(5);
20014                                   sb.append("(WITH ...");
20015               Skip2NextTerminator("(",")");
20016               jj_consume_token(7);
20017             } else {
20018               switch (jj_nt.kind) {
20019               case 5:
20020                 jj_consume_token(5);
20021           sb.append("(");
20022                 simpleNode = Expression();
20023                                 sb.append(simpleNode.getImage());
20024                 label_63:
20025                 while (true) {
20026                   switch (jj_nt.kind) {
20027                   case 6:
20028                     ;
20029                     break;
20030                   default:
20031                     jj_la1[262] = jj_gen;
20032                     break label_63;
20033                   }
20034                   jj_consume_token(6);
20035            sb.append(", ");
20036                   simpleNode = Expression();
20037                                   sb.append(simpleNode.getImage());
20038                 }
20039                 jj_consume_token(7);
20040          sb.append(")");
20041                 break;
20042               default:
20043                 jj_la1[265] = jj_gen;
20044                 jj_consume_token(-1);
20045                 throw new ParseException();
20046               }
20047             }
20048           }
20049         }
20050       }
20051    jjtree.closeNodeScope(jjtn000, true);
20052    jjtc000 = false;
20053  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
20054     } catch (Throwable jjte000) {
20055   if (jjtc000) {
20056     jjtree.clearNodeScope(jjtn000);
20057     jjtc000 = false;
20058   } else {
20059     jjtree.popNode();
20060   }
20061   if (jjte000 instanceof RuntimeException) {
20062     {if (true) throw (RuntimeException)jjte000;}
20063   }
20064   if (jjte000 instanceof ParseException) {
20065     {if (true) throw (ParseException)jjte000;}
20066   }
20067   {if (true) throw (Error)jjte000;}
20068     } finally {
20069   if (jjtc000) {
20070     jjtree.closeNodeScope(jjtn000, true);
20071   }
20072     }
20073     throw new Error("Missing return statement in function");
20074   }
20075 
20076   final public ASTPrimarySuffix PrimarySuffix() throws ParseException {
20077  /*@bgen(jjtree) PrimarySuffix */
20078   ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX);
20079   boolean jjtc000 = true;
20080   jjtree.openNodeScope(jjtn000);PLSQLNode suffixNode = null ; PLSQLNode arguments = null; StringBuilder sb = new StringBuilder() ;
20081     try {
20082       switch (jj_nt.kind) {
20083       case 3:
20084         jj_consume_token(3);
20085          sb.append(".");
20086         suffixNode = QualifiedID();
20087                                                            sb.append(suffixNode.toString()) ;
20088         break;
20089       case 2:
20090         jj_consume_token(2);
20091          sb.append("@");
20092         suffixNode = QualifiedID();
20093                                                            sb.append(suffixNode.toString()) ;
20094         break;
20095       case AT:
20096         jj_consume_token(AT);
20097           sb.append(" "); sb.append(token.image.toUpperCase());
20098         switch (jj_nt.kind) {
20099         case LOCAL:
20100           jj_consume_token(LOCAL);
20101                       sb.append(" "); sb.append(token.image.toUpperCase());
20102           break;
20103         case TIME:
20104           jj_consume_token(TIME);
20105           jj_consume_token(ZONE);
20106                                sb.append(" TIME ZONE");
20107           switch (jj_nt.kind) {
20108           case DBTIMEZONE:
20109             jj_consume_token(DBTIMEZONE);
20110                                   sb.append(" "); sb.append(token.image.toUpperCase());
20111             break;
20112           case SESSIONTIMEZONE:
20113             jj_consume_token(SESSIONTIMEZONE);
20114                                        sb.append(" "); sb.append(token.image.toUpperCase());
20115             break;
20116           case STRING_LITERAL:
20117             suffixNode = StringLiteral();
20118                                                   sb.append(" "); sb.append(suffixNode.toString());
20119             break;
20120           case 5:
20121           case 16:
20122           case 17:
20123           case REPLACE:
20124           case DEFINER:
20125           case CURRENT_USER:
20126           case LANGUAGE:
20127           case INLINE:
20128           case ADD:
20129           case AGGREGATE:
20130           case ARRAY:
20131           case AT:
20132           case ATTRIBUTE:
20133           case AUTHID:
20134           case BODY:
20135           case BULK:
20136           case BYTE:
20137           case CASCADE:
20138           case CASE:
20139           case CLOSE:
20140           case COALESCE:
20141           case COLLECT:
20142           case COLUMN:
20143           case COMMENT:
20144           case COMMIT:
20145           case CONSTRUCTOR:
20146           case CONTINUE:
20147           case CONVERT:
20148           case CURRENT:
20149           case CURSOR:
20150           case DATA:
20151           case DATE:
20152           case DAY:
20153           case DISABLE:
20154           case EDITIONABLE:
20155           case ELEMENT:
20156           case ENABLE:
20157           case ESCAPE:
20158           case EXCEPT:
20159           case EXCEPTIONS:
20160           case EXIT:
20161           case EXTERNAL:
20162           case EXTENDS:
20163           case EXTRACT:
20164           case FALSE:
20165           case FINAL:
20166           case FORCE:
20167           case FUNCTION:
20168           case GLOBAL:
20169           case HASH:
20170           case HEAP:
20171           case HOUR:
20172           case IMMEDIATE:
20173           case INDICES:
20174           case INDEXTYPE:
20175           case INDICATOR:
20176           case INSTANTIABLE:
20177           case INTERVAL:
20178           case INVALIDATE:
20179           case ISOLATION:
20180           case JAVA:
20181           case LEVEL:
20182           case LIMIT:
20183           case LOOP:
20184           case MAP:
20185           case MAX:
20186           case MEMBER:
20187           case MERGE:
20188           case MIN:
20189           case MINUTE:
20190           case MLSLABEL:
20191           case MODIFY:
20192           case MOD:
20193           case MONTH:
20194           case NATURAL:
20195           case NEW:
20196           case NEW_DOT:
20197           case NO:
20198           case NONEDITIONABLE:
20199           case NOT:
20200           case NULL:
20201           case NULLIF:
20202           case OBJECT:
20203           case OID:
20204           case OPAQUE:
20205           case OPEN:
20206           case OPERATOR:
20207           case ORGANIZATION:
20208           case OTHERS:
20209           case OVERRIDING:
20210           case PACKAGE:
20211           case PARTITION:
20212           case PRESERVE:
20213           case PRIVATE:
20214           case PROCEDURE:
20215           case RANGE:
20216           case RAW:
20217           case REAL:
20218           case RECORD:
20219           case REF:
20220           case RELEASE:
20221           case RELIES_ON:
20222           case RENAME:
20223           case RESULT:
20224           case RETURN:
20225           case RETURNING:
20226           case REVERSE:
20227           case ROLLBACK:
20228           case ROW:
20229           case ROWS:
20230           case ROWID:
20231           case ROWNUM:
20232           case SAVE:
20233           case SAVEPOINT:
20234           case SECOND:
20235           case SELECT:
20236           case SELF:
20237           case SET:
20238           case SPACE:
20239           case SQL:
20240           case SQLCODE:
20241           case SQLERRM:
20242           case STATIC:
20243           case SUBTYPE:
20244           case SUBSTITUTABLE:
20245           case SUCCESSFUL:
20246           case SYSDATE:
20247           case SYS_REFCURSOR:
20248           case TEMPORARY:
20249           case TIME:
20250           case TIMESTAMP:
20251           case TIMEZONE_REGION:
20252           case TIMEZONE_ABBR:
20253           case TIMEZONE_MINUTE:
20254           case TIMEZONE_HOUR:
20255           case TRANSACTION:
20256           case TRUE:
20257           case TYPE:
20258           case UNDER:
20259           case USING:
20260           case YES:
20261           case SHOW:
20262           case A:
20263           case DOUBLE:
20264           case DEC:
20265           case PRECISION:
20266           case INT:
20267           case NUMERIC:
20268           case NCHAR:
20269           case NVARCHAR2:
20270           case STRING:
20271           case UROWID:
20272           case VARRAY:
20273           case VARYING:
20274           case BFILE:
20275           case BLOB:
20276           case CLOB:
20277           case NCLOB:
20278           case YEAR:
20279           case LOCAL:
20280           case WITH:
20281           case ZONE:
20282           case CHARACTER:
20283           case AFTER:
20284           case BEFORE:
20285           case OLD:
20286           case PARENT:
20287           case CC_IF:
20288           case ANALYZE:
20289           case ASSOCIATE:
20290           case AUDIT:
20291           case COMPOUND:
20292           case DATABASE:
20293           case CALL:
20294           case DDL:
20295           case DISASSOCIATE:
20296           case EACH:
20297           case FOLLOWS:
20298           case LOGOFF:
20299           case LOGON:
20300           case NESTED:
20301           case NOAUDIT:
20302           case SCHEMA:
20303           case SERVERERROR:
20304           case SHUTDOWN:
20305           case STARTUP:
20306           case STATEMENT:
20307           case STATISTICS:
20308           case SUSPEND:
20309           case TRUNCATE:
20310           case WRAPPED:
20311           case LIBRARY:
20312           case NAME:
20313           case STRUCT:
20314           case CONTEXT:
20315           case PARAMETERS:
20316           case LENGTH:
20317           case TDO:
20318           case MAXLEN:
20319           case CHARSETID:
20320           case CHARSETFORM:
20321           case ACCEPT:
20322           case ACCESSIBLE:
20323           case COPY:
20324           case DEFINE:
20325           case DISCONNECT:
20326           case HOST:
20327           case PRINT:
20328           case QUIT:
20329           case REMARK:
20330           case UNDEFINE:
20331           case VARIABLE:
20332           case WHENEVER:
20333           case ATTACH:
20334           case CAST:
20335           case TREAT:
20336           case TRIM:
20337           case LEFT:
20338           case RIGHT:
20339           case BOTH:
20340           case EMPTY:
20341           case MULTISET:
20342           case SUBMULTISET:
20343           case LEADING:
20344           case TRAILING:
20345           case CHAR_CS:
20346           case NCHAR_CS:
20347           case AUTHENTICATED:
20348           case LINK:
20349           case SHARED:
20350           case DIRECTORY:
20351           case USER:
20352           case IDENTIFIER:
20353           case UNSIGNED_NUMERIC_LITERAL:
20354           case CHARACTER_LITERAL:
20355           case QUOTED_LITERAL:
20356             suffixNode = Expression();
20357                                                sb.append(" "); sb.append(suffixNode.toString());
20358             break;
20359           default:
20360             jj_la1[266] = jj_gen;
20361             jj_consume_token(-1);
20362             throw new ParseException();
20363           }
20364           break;
20365         default:
20366           jj_la1[267] = jj_gen;
20367           jj_consume_token(-1);
20368           throw new ParseException();
20369         }
20370         break;
20371       case 5:
20372         arguments = Arguments();
20373                                sb.append(arguments) ;
20374         break;
20375       default:
20376         jj_la1[268] = jj_gen;
20377         jj_consume_token(-1);
20378         throw new ParseException();
20379       }
20380    jjtree.closeNodeScope(jjtn000, true);
20381    jjtc000 = false;
20382  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
20383     } catch (Throwable jjte000) {
20384     if (jjtc000) {
20385       jjtree.clearNodeScope(jjtn000);
20386       jjtc000 = false;
20387     } else {
20388       jjtree.popNode();
20389     }
20390     if (jjte000 instanceof RuntimeException) {
20391       {if (true) throw (RuntimeException)jjte000;}
20392     }
20393     if (jjte000 instanceof ParseException) {
20394       {if (true) throw (ParseException)jjte000;}
20395     }
20396     {if (true) throw (Error)jjte000;}
20397     } finally {
20398     if (jjtc000) {
20399       jjtree.closeNodeScope(jjtn000, true);
20400     }
20401     }
20402     throw new Error("Missing return statement in function");
20403   }
20404 
20405   final public ASTLiteral Literal() throws ParseException {
20406  /*@bgen(jjtree) Literal */
20407  ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);
20408  boolean jjtc000 = true;
20409  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20410  Token t = null ;
20411     try {
20412       switch (jj_nt.kind) {
20413       case UNSIGNED_NUMERIC_LITERAL:
20414         simpleNode = NumericLiteral();
20415         break;
20416       case CHARACTER_LITERAL:
20417         t = jj_consume_token(CHARACTER_LITERAL);
20418         break;
20419       case STRING_LITERAL:
20420         //<STRING_LITERAL> {literal = token.toString(); }
20421           simpleNode = StringLiteral();
20422         break;
20423       case FALSE:
20424       case TRUE:
20425         simpleNode = BooleanLiteral();
20426         break;
20427       case NULL:
20428         simpleNode = NullLiteral();
20429         break;
20430       case DATE:
20431       case INTERVAL:
20432       case TIMESTAMP:
20433         simpleNode = DateTimeLiteral();
20434         break;
20435       default:
20436         jj_la1[269] = jj_gen;
20437         jj_consume_token(-1);
20438         throw new ParseException();
20439       }
20440    jjtree.closeNodeScope(jjtn000, true);
20441    jjtc000 = false;
20442    if (null != simpleNode)
20443    {
20444      jjtn000.setImage( simpleNode.getImage() ) ;
20445    }
20446    else if (null != t)
20447    {
20448      jjtn000.setImage( t.image ) ;
20449    }
20450    {if (true) return jjtn000 ;}
20451     } catch (Throwable jjte000) {
20452     if (jjtc000) {
20453       jjtree.clearNodeScope(jjtn000);
20454       jjtc000 = false;
20455     } else {
20456       jjtree.popNode();
20457     }
20458     if (jjte000 instanceof RuntimeException) {
20459       {if (true) throw (RuntimeException)jjte000;}
20460     }
20461     if (jjte000 instanceof ParseException) {
20462       {if (true) throw (ParseException)jjte000;}
20463     }
20464     {if (true) throw (Error)jjte000;}
20465     } finally {
20466     if (jjtc000) {
20467       jjtree.closeNodeScope(jjtn000, true);
20468     }
20469     }
20470     throw new Error("Missing return statement in function");
20471   }
20472 
20473   final public ASTStringLiteral StringLiteral() throws ParseException {
20474  /*@bgen(jjtree) StringLiteral */
20475         ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL);
20476         boolean jjtc000 = true;
20477         jjtree.openNodeScope(jjtn000);Token thisToken = null;
20478         StringBuilder literal = new StringBuilder() ;
20479         char startDelimiter ;
20480         char endDelimiter ;
20481         String terminator = null;
20482     try {
20483       thisToken = jj_consume_token(STRING_LITERAL);
20484    literal.append(thisToken.image);
20485    /*
20486    This might be Q-Quoted string and this might be only a partial string
20487    The token will only match up to the first single quote.
20488    The code below appends any remaining part, theh returns the complete string
20489    */
20490    if (thisToken.image.toUpperCase().startsWith("Q'")
20491        && thisToken.image.length() > 2
20492       )
20493    {
20494    // Get the first token of the string so that the delimiter can be identified
20495 
20496      startDelimiter= thisToken.image.charAt(2) ;
20497      /*
20498      if the start delimiter is one of [, {, <, or (, the end delimiter
20499      is the corresponding closing character
20500      */
20501      switch (startDelimiter)
20502      {
20503       case '<' : endDelimiter = '>' ; break ;
20504       case '{' : endDelimiter = '}' ;  break ;
20505       case '(' : endDelimiter = ')' ;  break ;
20506       case '[' : endDelimiter = ']' ;  break ;
20507       default: endDelimiter = startDelimiter ;
20508      }
20509 
20510      terminator = new String(endDelimiter + "'");
20511      if (!thisToken.image.endsWith(terminator))
20512      {
20513        //Loop until we find atoken that ends with a single-quote precede by the terminator
20514        literal.append(ReadPastNextOccurrence(terminator));
20515      }
20516    }
20517    jjtree.closeNodeScope(jjtn000, true);
20518    jjtc000 = false;
20519    jjtn000.setImage(literal.toString()) ;  jjtn000.value = literal.toString() ; {if (true) return jjtn000 ;}
20520     } finally {
20521    if (jjtc000) {
20522      jjtree.closeNodeScope(jjtn000, true);
20523    }
20524     }
20525     throw new Error("Missing return statement in function");
20526   }
20527 
20528   final public ASTBooleanLiteral BooleanLiteral() throws ParseException {
20529  /*@bgen(jjtree) BooleanLiteral */
20530   ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);
20531   boolean jjtc000 = true;
20532   jjtree.openNodeScope(jjtn000);
20533     try {
20534       switch (jj_nt.kind) {
20535       case TRUE:
20536         jj_consume_token(TRUE);
20537         break;
20538       case FALSE:
20539         jj_consume_token(FALSE);
20540         break;
20541       default:
20542         jj_la1[270] = jj_gen;
20543         jj_consume_token(-1);
20544         throw new ParseException();
20545       }
20546     jjtree.closeNodeScope(jjtn000, true);
20547     jjtc000 = false;
20548    jjtn000.setImage(token.image) ;
20549    {if (true) return jjtn000;}
20550     } finally {
20551    if (jjtc000) {
20552      jjtree.closeNodeScope(jjtn000, true);
20553    }
20554     }
20555     throw new Error("Missing return statement in function");
20556   }
20557 
20558   final public ASTNullLiteral NullLiteral() throws ParseException {
20559  /*@bgen(jjtree) NullLiteral */
20560   ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
20561   boolean jjtc000 = true;
20562   jjtree.openNodeScope(jjtn000);
20563     try {
20564       jj_consume_token(NULL);
20565    jjtree.closeNodeScope(jjtn000, true);
20566    jjtc000 = false;
20567   jjtn000.setImage(token.image) ;
20568   {if (true) return jjtn000 ;}
20569     } finally {
20570     if (jjtc000) {
20571       jjtree.closeNodeScope(jjtn000, true);
20572     }
20573     }
20574     throw new Error("Missing return statement in function");
20575   }
20576 
20577   final public ASTMultiSetCondition MultiSetCondition() throws ParseException {
20578  /*@bgen(jjtree) MultiSetCondition */
20579   ASTMultiSetCondition jjtn000 = new ASTMultiSetCondition(this, JJTMULTISETCONDITION);
20580   boolean jjtc000 = true;
20581   jjtree.openNodeScope(jjtn000);
20582     try {
20583       switch (jj_nt.kind) {
20584       case A:
20585         jj_consume_token(A);
20586         jj_consume_token(SET);
20587         break;
20588       case EMPTY:
20589         jj_consume_token(EMPTY);
20590         break;
20591       default:
20592         jj_la1[271] = jj_gen;
20593         jj_consume_token(-1);
20594         throw new ParseException();
20595       }
20596    jjtree.closeNodeScope(jjtn000, true);
20597    jjtc000 = false;
20598   {if (true) return jjtn000;}
20599     } finally {
20600     if (jjtc000) {
20601       jjtree.closeNodeScope(jjtn000, true);
20602     }
20603     }
20604     throw new Error("Missing return statement in function");
20605   }
20606 
20607 /** Recognizes a numeric literal.
20608 * This may look like token, but it isn't. Not atomic enough.
20609 * E.g. "+1" would be valid literal, which make parsing of "i+1" impossible
20610 * (here, we have tokens "i", "+" and "1")
20611 */
20612   final public ASTNumericLiteral NumericLiteral() throws ParseException {
20613  /*@bgen(jjtree) NumericLiteral */
20614  ASTNumericLiteral jjtn000 = new ASTNumericLiteral(this, JJTNUMERICLITERAL);
20615  boolean jjtc000 = true;
20616  jjtree.openNodeScope(jjtn000);Token t = null ;
20617     try {
20618       //Essentially unchanged, as it previouly returned a Token 
20619                       t = jj_consume_token(UNSIGNED_NUMERIC_LITERAL);
20620           jjtree.closeNodeScope(jjtn000, true);
20621           jjtc000 = false;
20622          jjtn000.setImage(t.image) ;
20623          {if (true) return jjtn000;}
20624     } finally {
20625           if (jjtc000) {
20626             jjtree.closeNodeScope(jjtn000, true);
20627           }
20628     }
20629     throw new Error("Missing return statement in function");
20630   }
20631 
20632 /** This cannot be a token because these are valid labels '<< next_msg >>", '<<"OUTER LOOP">>'  
20633 */
20634   final public ASTLabel Label() throws ParseException {
20635  /*@bgen(jjtree) Label */
20636  ASTLabel jjtn000 = new ASTLabel(this, JJTLABEL);
20637  boolean jjtc000 = true;
20638  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20639     try {
20640       jj_consume_token(21);
20641       simpleNode = UnqualifiedID();
20642       jj_consume_token(22);
20643           jjtree.closeNodeScope(jjtn000, true);
20644           jjtc000 = false;
20645         jjtn000.setImage( simpleNode.getImage() ) ;
20646         {if (true) return jjtn000;}
20647     } catch (Throwable jjte000) {
20648           if (jjtc000) {
20649             jjtree.clearNodeScope(jjtn000);
20650             jjtc000 = false;
20651           } else {
20652             jjtree.popNode();
20653           }
20654           if (jjte000 instanceof RuntimeException) {
20655             {if (true) throw (RuntimeException)jjte000;}
20656           }
20657           if (jjte000 instanceof ParseException) {
20658             {if (true) throw (ParseException)jjte000;}
20659           }
20660           {if (true) throw (Error)jjte000;}
20661     } finally {
20662           if (jjtc000) {
20663             jjtree.closeNodeScope(jjtn000, true);
20664           }
20665     }
20666     throw new Error("Missing return statement in function");
20667   }
20668 
20669   final public ASTName Name() throws ParseException {
20670  /*@bgen(jjtree) Name */
20671  ASTName jjtn000 = new ASTName(this, JJTNAME);
20672  boolean jjtc000 = true;
20673  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20674  StringBuilder sb = new StringBuilder();
20675     try {
20676       simpleNode = UnqualifiedID();
20677                                    sb.append(simpleNode.getImage()) ;
20678       label_64:
20679       while (true) {
20680         if (jj_2_57(2)) {
20681           ;
20682         } else {
20683           break label_64;
20684         }
20685         switch (jj_nt.kind) {
20686         case 3:
20687           jj_consume_token(3);
20688             sb.append(".") ;
20689           break;
20690         case 11:
20691           jj_consume_token(11);
20692                                        sb.append("%") ;
20693           break;
20694         default:
20695           jj_la1[272] = jj_gen;
20696           jj_consume_token(-1);
20697           throw new ParseException();
20698         }
20699         //QualifiedID() 
20700             simpleNode = QualifiedID();
20701                                   sb.append(simpleNode.getImage()) ;
20702       }
20703     jjtree.closeNodeScope(jjtn000, true);
20704     jjtc000 = false;
20705   jjtn000.setImage(sb.toString()) ;
20706   {if (true) return jjtn000;}
20707     } catch (Throwable jjte000) {
20708     if (jjtc000) {
20709       jjtree.clearNodeScope(jjtn000);
20710       jjtc000 = false;
20711     } else {
20712       jjtree.popNode();
20713     }
20714     if (jjte000 instanceof RuntimeException) {
20715       {if (true) throw (RuntimeException)jjte000;}
20716     }
20717     if (jjte000 instanceof ParseException) {
20718       {if (true) throw (ParseException)jjte000;}
20719     }
20720     {if (true) throw (Error)jjte000;}
20721     } finally {
20722     if (jjtc000) {
20723       jjtree.closeNodeScope(jjtn000, true);
20724     }
20725     }
20726     throw new Error("Missing return statement in function");
20727   }
20728 
20729   final public ASTQualifiedName QualifiedName() throws ParseException {
20730  /*@bgen(jjtree) QualifiedName */
20731  ASTQualifiedName jjtn000 = new ASTQualifiedName(this, JJTQUALIFIEDNAME);
20732  boolean jjtc000 = true;
20733  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20734  StringBuilder sb = new StringBuilder();
20735     try {
20736       simpleNode = UnqualifiedID();
20737                                         sb.append(simpleNode.getImage()) ;
20738       label_65:
20739       while (true) {
20740         switch (jj_nt.kind) {
20741         case 3:
20742           ;
20743           break;
20744         default:
20745           jj_la1[273] = jj_gen;
20746           break label_65;
20747         }
20748         jj_consume_token(3);
20749         simpleNode = QualifiedID();
20750                                               sb.append(".") ; sb.append(simpleNode.getImage()) ;
20751       }
20752           jjtree.closeNodeScope(jjtn000, true);
20753           jjtc000 = false;
20754          jjtn000.setImage(sb.toString()) ;
20755          {if (true) return jjtn000 ;}
20756     } catch (Throwable jjte000) {
20757           if (jjtc000) {
20758             jjtree.clearNodeScope(jjtn000);
20759             jjtc000 = false;
20760           } else {
20761             jjtree.popNode();
20762           }
20763           if (jjte000 instanceof RuntimeException) {
20764             {if (true) throw (RuntimeException)jjte000;}
20765           }
20766           if (jjte000 instanceof ParseException) {
20767             {if (true) throw (ParseException)jjte000;}
20768           }
20769           {if (true) throw (Error)jjte000;}
20770     } finally {
20771           if (jjtc000) {
20772             jjtree.closeNodeScope(jjtn000, true);
20773           }
20774     }
20775     throw new Error("Missing return statement in function");
20776   }
20777 
20778   final public ASTArguments Arguments() throws ParseException {
20779  /*@bgen(jjtree) Arguments */
20780   ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
20781   boolean jjtc000 = true;
20782   jjtree.openNodeScope(jjtn000);
20783     try {
20784       jj_consume_token(5);
20785       switch (jj_nt.kind) {
20786       case 5:
20787       case 16:
20788       case 17:
20789       case REPLACE:
20790       case DEFINER:
20791       case CURRENT_USER:
20792       case LANGUAGE:
20793       case INLINE:
20794       case ADD:
20795       case AGGREGATE:
20796       case ARRAY:
20797       case AT:
20798       case ATTRIBUTE:
20799       case AUTHID:
20800       case BODY:
20801       case BULK:
20802       case BYTE:
20803       case CASCADE:
20804       case CASE:
20805       case CLOSE:
20806       case COALESCE:
20807       case COLLECT:
20808       case COLUMN:
20809       case COMMENT:
20810       case COMMIT:
20811       case CONSTRUCTOR:
20812       case CONTINUE:
20813       case CONVERT:
20814       case CURRENT:
20815       case CURSOR:
20816       case DATA:
20817       case DATE:
20818       case DAY:
20819       case DISABLE:
20820       case EDITIONABLE:
20821       case ELEMENT:
20822       case ENABLE:
20823       case ESCAPE:
20824       case EXCEPT:
20825       case EXCEPTIONS:
20826       case EXIT:
20827       case EXTERNAL:
20828       case EXTENDS:
20829       case EXTRACT:
20830       case FALSE:
20831       case FINAL:
20832       case FORCE:
20833       case FUNCTION:
20834       case GLOBAL:
20835       case HASH:
20836       case HEAP:
20837       case HOUR:
20838       case IMMEDIATE:
20839       case INDICES:
20840       case INDEXTYPE:
20841       case INDICATOR:
20842       case INSTANTIABLE:
20843       case INTERVAL:
20844       case INVALIDATE:
20845       case ISOLATION:
20846       case JAVA:
20847       case LEVEL:
20848       case LIMIT:
20849       case LOOP:
20850       case MAP:
20851       case MAX:
20852       case MEMBER:
20853       case MERGE:
20854       case MIN:
20855       case MINUTE:
20856       case MLSLABEL:
20857       case MODIFY:
20858       case MOD:
20859       case MONTH:
20860       case NATURAL:
20861       case NEW:
20862       case NEW_DOT:
20863       case NO:
20864       case NONEDITIONABLE:
20865       case NOT:
20866       case NULL:
20867       case NULLIF:
20868       case OBJECT:
20869       case OID:
20870       case OPAQUE:
20871       case OPEN:
20872       case OPERATOR:
20873       case ORGANIZATION:
20874       case OTHERS:
20875       case OVERRIDING:
20876       case PACKAGE:
20877       case PARTITION:
20878       case PRESERVE:
20879       case PRIVATE:
20880       case PROCEDURE:
20881       case RANGE:
20882       case RAW:
20883       case REAL:
20884       case RECORD:
20885       case REF:
20886       case RELEASE:
20887       case RELIES_ON:
20888       case RENAME:
20889       case RESULT:
20890       case RETURN:
20891       case RETURNING:
20892       case REVERSE:
20893       case ROLLBACK:
20894       case ROW:
20895       case ROWS:
20896       case ROWID:
20897       case ROWNUM:
20898       case SAVE:
20899       case SAVEPOINT:
20900       case SECOND:
20901       case SELECT:
20902       case SELF:
20903       case SET:
20904       case SPACE:
20905       case SQL:
20906       case SQLCODE:
20907       case SQLERRM:
20908       case STATIC:
20909       case SUBTYPE:
20910       case SUBSTITUTABLE:
20911       case SUCCESSFUL:
20912       case SYSDATE:
20913       case SYS_REFCURSOR:
20914       case TEMPORARY:
20915       case TIME:
20916       case TIMESTAMP:
20917       case TIMEZONE_REGION:
20918       case TIMEZONE_ABBR:
20919       case TIMEZONE_MINUTE:
20920       case TIMEZONE_HOUR:
20921       case TRANSACTION:
20922       case TRUE:
20923       case TYPE:
20924       case UNDER:
20925       case USING:
20926       case YES:
20927       case SHOW:
20928       case A:
20929       case DOUBLE:
20930       case DEC:
20931       case PRECISION:
20932       case INT:
20933       case NUMERIC:
20934       case NCHAR:
20935       case NVARCHAR2:
20936       case STRING:
20937       case UROWID:
20938       case VARRAY:
20939       case VARYING:
20940       case BFILE:
20941       case BLOB:
20942       case CLOB:
20943       case NCLOB:
20944       case YEAR:
20945       case LOCAL:
20946       case WITH:
20947       case ZONE:
20948       case CHARACTER:
20949       case AFTER:
20950       case BEFORE:
20951       case OLD:
20952       case PARENT:
20953       case CC_IF:
20954       case ANALYZE:
20955       case ASSOCIATE:
20956       case AUDIT:
20957       case COMPOUND:
20958       case DATABASE:
20959       case CALL:
20960       case DDL:
20961       case DISASSOCIATE:
20962       case EACH:
20963       case FOLLOWS:
20964       case LOGOFF:
20965       case LOGON:
20966       case NESTED:
20967       case NOAUDIT:
20968       case SCHEMA:
20969       case SERVERERROR:
20970       case SHUTDOWN:
20971       case STARTUP:
20972       case STATEMENT:
20973       case STATISTICS:
20974       case SUSPEND:
20975       case TRUNCATE:
20976       case WRAPPED:
20977       case LIBRARY:
20978       case NAME:
20979       case STRUCT:
20980       case CONTEXT:
20981       case PARAMETERS:
20982       case LENGTH:
20983       case TDO:
20984       case MAXLEN:
20985       case CHARSETID:
20986       case CHARSETFORM:
20987       case ACCEPT:
20988       case ACCESSIBLE:
20989       case COPY:
20990       case DEFINE:
20991       case DISCONNECT:
20992       case HOST:
20993       case PRINT:
20994       case QUIT:
20995       case REMARK:
20996       case UNDEFINE:
20997       case VARIABLE:
20998       case WHENEVER:
20999       case ATTACH:
21000       case CAST:
21001       case TREAT:
21002       case TRIM:
21003       case LEFT:
21004       case RIGHT:
21005       case BOTH:
21006       case EMPTY:
21007       case MULTISET:
21008       case SUBMULTISET:
21009       case LEADING:
21010       case TRAILING:
21011       case CHAR_CS:
21012       case NCHAR_CS:
21013       case DBTIMEZONE:
21014       case SESSIONTIMEZONE:
21015       case AUTHENTICATED:
21016       case LINK:
21017       case SHARED:
21018       case DIRECTORY:
21019       case USER:
21020       case IDENTIFIER:
21021       case UNSIGNED_NUMERIC_LITERAL:
21022       case CHARACTER_LITERAL:
21023       case STRING_LITERAL:
21024       case QUOTED_LITERAL:
21025         ArgumentList();
21026         break;
21027       default:
21028         jj_la1[274] = jj_gen;
21029         ;
21030       }
21031       jj_consume_token(7);
21032    jjtree.closeNodeScope(jjtn000, true);
21033    jjtc000 = false;
21034  {if (true) return jjtn000 ;}
21035     } catch (Throwable jjte000) {
21036     if (jjtc000) {
21037       jjtree.clearNodeScope(jjtn000);
21038       jjtc000 = false;
21039     } else {
21040       jjtree.popNode();
21041     }
21042     if (jjte000 instanceof RuntimeException) {
21043       {if (true) throw (RuntimeException)jjte000;}
21044     }
21045     if (jjte000 instanceof ParseException) {
21046       {if (true) throw (ParseException)jjte000;}
21047     }
21048     {if (true) throw (Error)jjte000;}
21049     } finally {
21050     if (jjtc000) {
21051       jjtree.closeNodeScope(jjtn000, true);
21052     }
21053     }
21054     throw new Error("Missing return statement in function");
21055   }
21056 
21057   final public ASTArgumentList ArgumentList() throws ParseException {
21058  /*@bgen(jjtree) ArgumentList */
21059   ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);
21060   boolean jjtc000 = true;
21061   jjtree.openNodeScope(jjtn000);
21062     try {
21063       Argument();
21064       label_66:
21065       while (true) {
21066         switch (jj_nt.kind) {
21067         case 6:
21068           ;
21069           break;
21070         default:
21071           jj_la1[275] = jj_gen;
21072           break label_66;
21073         }
21074         jj_consume_token(6);
21075         Argument();
21076       }
21077    jjtree.closeNodeScope(jjtn000, true);
21078    jjtc000 = false;
21079  {if (true) return jjtn000 ;}
21080     } catch (Throwable jjte000) {
21081     if (jjtc000) {
21082       jjtree.clearNodeScope(jjtn000);
21083       jjtc000 = false;
21084     } else {
21085       jjtree.popNode();
21086     }
21087     if (jjte000 instanceof RuntimeException) {
21088       {if (true) throw (RuntimeException)jjte000;}
21089     }
21090     if (jjte000 instanceof ParseException) {
21091       {if (true) throw (ParseException)jjte000;}
21092     }
21093     {if (true) throw (Error)jjte000;}
21094     } finally {
21095     if (jjtc000) {
21096       jjtree.closeNodeScope(jjtn000, true);
21097     }
21098     }
21099     throw new Error("Missing return statement in function");
21100   }
21101 
21102   final public ASTArgument Argument() throws ParseException {
21103  /*@bgen(jjtree) Argument */
21104  ASTArgument jjtn000 = new ASTArgument(this, JJTARGUMENT);
21105  boolean jjtc000 = true;
21106  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21107     try {
21108       if (jj_2_58(2)) {
21109         simpleNode = UnqualifiedID();
21110         switch (jj_nt.kind) {
21111         case 23:
21112           jj_consume_token(23);
21113           break;
21114         case AS:
21115           jj_consume_token(AS);
21116           break;
21117         default:
21118           jj_la1[276] = jj_gen;
21119           jj_consume_token(-1);
21120           throw new ParseException();
21121         }
21122       } else {
21123         ;
21124       }
21125       Expression();
21126       switch (jj_nt.kind) {
21127       case USING:
21128         jj_consume_token(USING);
21129         switch (jj_nt.kind) {
21130         case CHAR_CS:
21131           jj_consume_token(CHAR_CS);
21132           break;
21133         case NCHAR_CS:
21134           jj_consume_token(NCHAR_CS);
21135           break;
21136         default:
21137           jj_la1[277] = jj_gen;
21138           jj_consume_token(-1);
21139           throw new ParseException();
21140         }
21141         break;
21142       default:
21143         jj_la1[278] = jj_gen;
21144         ;
21145       }
21146    jjtree.closeNodeScope(jjtn000, true);
21147    jjtc000 = false;
21148  if (null != simpleNode) { jjtn000.setImage(simpleNode.getImage()) ; }
21149  {if (true) return jjtn000 ;}
21150     } catch (Throwable jjte000) {
21151           if (jjtc000) {
21152             jjtree.clearNodeScope(jjtn000);
21153             jjtc000 = false;
21154           } else {
21155             jjtree.popNode();
21156           }
21157           if (jjte000 instanceof RuntimeException) {
21158             {if (true) throw (RuntimeException)jjte000;}
21159           }
21160           if (jjte000 instanceof ParseException) {
21161             {if (true) throw (ParseException)jjte000;}
21162           }
21163           {if (true) throw (Error)jjte000;}
21164     } finally {
21165           if (jjtc000) {
21166             jjtree.closeNodeScope(jjtn000, true);
21167           }
21168     }
21169     throw new Error("Missing return statement in function");
21170   }
21171 
21172 // ============================================================================
21173 // D E C L A R A T I O N S
21174 // ============================================================================
21175   final public ASTVariableOrConstantDeclaration VariableOrConstantDeclaration() throws ParseException {
21176  /*@bgen(jjtree) VariableOrConstantDeclaration */
21177   ASTVariableOrConstantDeclaration jjtn000 = new ASTVariableOrConstantDeclaration(this, JJTVARIABLEORCONSTANTDECLARATION);
21178   boolean jjtc000 = true;
21179   jjtree.openNodeScope(jjtn000);
21180     try {
21181       VariableOrConstantDeclarator();
21182       jj_consume_token(4);
21183     jjtree.closeNodeScope(jjtn000, true);
21184     jjtc000 = false;
21185     {if (true) return jjtn000 ;}
21186     } catch (Throwable jjte000) {
21187     if (jjtc000) {
21188       jjtree.clearNodeScope(jjtn000);
21189       jjtc000 = false;
21190     } else {
21191       jjtree.popNode();
21192     }
21193     if (jjte000 instanceof RuntimeException) {
21194       {if (true) throw (RuntimeException)jjte000;}
21195     }
21196     if (jjte000 instanceof ParseException) {
21197       {if (true) throw (ParseException)jjte000;}
21198     }
21199     {if (true) throw (Error)jjte000;}
21200     } finally {
21201     if (jjtc000) {
21202       jjtree.closeNodeScope(jjtn000, true);
21203     }
21204     }
21205     throw new Error("Missing return statement in function");
21206   }
21207 
21208   final public ASTDatatypeDeclaration DatatypeDeclaration() throws ParseException {
21209  /*@bgen(jjtree) DatatypeDeclaration */
21210  ASTDatatypeDeclaration jjtn000 = new ASTDatatypeDeclaration(this, JJTDATATYPEDECLARATION);
21211  boolean jjtc000 = true;
21212  jjtree.openNodeScope(jjtn000);Token t ;
21213     try {
21214       t = jj_consume_token(IDENTIFIER);
21215     jjtree.closeNodeScope(jjtn000, true);
21216     jjtc000 = false;
21217     jjtn000.setImage(t.image) ;  {if (true) return jjtn000 ;}
21218     } finally {
21219     if (jjtc000) {
21220       jjtree.closeNodeScope(jjtn000, true);
21221     }
21222     }
21223     throw new Error("Missing return statement in function");
21224   }
21225 
21226   final public ASTPragma Pragma() throws ParseException {
21227  /*@bgen(jjtree) Pragma */
21228   ASTPragma jjtn000 = new ASTPragma(this, JJTPRAGMA);
21229   boolean jjtc000 = true;
21230   jjtree.openNodeScope(jjtn000);
21231     try {
21232       jj_consume_token(PRAGMA);
21233       switch (jj_nt.kind) {
21234       case SERIALLY_REUSABLE:
21235         jj_consume_token(SERIALLY_REUSABLE);
21236         break;
21237       case AUTONOMOUS_TRANSACTION:
21238         jj_consume_token(AUTONOMOUS_TRANSACTION);
21239         break;
21240       case TIMESTAMP:
21241         jj_consume_token(TIMESTAMP);
21242         jj_consume_token(5);
21243         StringLiteral();
21244         jj_consume_token(7);
21245         break;
21246       case RESTRICT_REFERENCES:
21247         jj_consume_token(RESTRICT_REFERENCES);
21248         jj_consume_token(5);
21249         ID();
21250         label_67:
21251         while (true) {
21252           jj_consume_token(6);
21253           switch (jj_nt.kind) {
21254           case REPLACE:
21255           case DEFINER:
21256           case CURRENT_USER:
21257           case SERIALLY_REUSABLE:
21258           case RESTRICT_REFERENCES:
21259           case EXCEPTION_INIT:
21260           case AUTONOMOUS_TRANSACTION:
21261           case LANGUAGE:
21262           case INLINE:
21263           case ADD:
21264           case AGGREGATE:
21265           case ALL:
21266           case ALTER:
21267           case AND:
21268           case ANY:
21269           case ARRAY:
21270           case AS:
21271           case ASC:
21272           case AT:
21273           case ATTRIBUTE:
21274           case AUTHID:
21275           case AVG:
21276           case BETWEEN:
21277           case BINARY_INTEGER:
21278           case BODY:
21279           case BOOLEAN:
21280           case BULK:
21281           case BY:
21282           case BYTE:
21283           case CASCADE:
21284           case CASE:
21285           case CHAR:
21286           case CHAR_BASE:
21287           case CHECK:
21288           case CLOSE:
21289           case CLUSTER:
21290           case COALESCE:
21291           case COLLECT:
21292           case COLUMN:
21293           case COMMENT:
21294           case COMMIT:
21295           case COMPRESS:
21296           case CONNECT:
21297           case CONSTANT:
21298           case CONSTRUCTOR:
21299           case CONTINUE:
21300           case CONVERT:
21301           case CREATE:
21302           case CURRENT:
21303           case CURRVAL:
21304           case CURSOR:
21305           case DATA:
21306           case DATE:
21307           case DAY:
21308           case DECLARE:
21309           case DECIMAL:
21310           case _DEFAULT:
21311           case DELETE:
21312           case DESC:
21313           case DISABLE:
21314           case DISTINCT:
21315           case DO:
21316           case DROP:
21317           case EDITIONABLE:
21318           case ELEMENT:
21319           case ELSE:
21320           case ELSIF:
21321           case ENABLE:
21322           case ESCAPE:
21323           case EXCEPT:
21324           case EXCEPTION:
21325           case EXCEPTIONS:
21326           case EXCLUSIVE:
21327           case EXECUTE:
21328           case EXISTS:
21329           case EXIT:
21330           case EXTERNAL:
21331           case EXTENDS:
21332           case EXTRACT:
21333           case FALSE:
21334           case FETCH:
21335           case FINAL:
21336           case FLOAT:
21337           case FOR:
21338           case FORALL:
21339           case FORCE:
21340           case FROM:
21341           case FUNCTION:
21342           case GLOBAL:
21343           case GOTO:
21344           case GROUP:
21345           case HASH:
21346           case HAVING:
21347           case HEAP:
21348           case HOUR:
21349           case IF:
21350           case IMMEDIATE:
21351           case IN:
21352           case INDEX:
21353           case INDICES:
21354           case INDEXTYPE:
21355           case INDICATOR:
21356           case INSERT:
21357           case INSTANTIABLE:
21358           case INTEGER:
21359           case INTERFACE:
21360           case INTERSECT:
21361           case INTERVAL:
21362           case INTO:
21363           case INVALIDATE:
21364           case IS:
21365           case ISOLATION:
21366           case JAVA:
21367           case LEVEL:
21368           case LIKE:
21369           case LIMIT:
21370           case LIMITED:
21371           case LOCK:
21372           case LONG:
21373           case LOOP:
21374           case MAP:
21375           case MAX:
21376           case MEMBER:
21377           case MERGE:
21378           case MIN:
21379           case MINUS:
21380           case MINUTE:
21381           case MLSLABEL:
21382           case MODIFY:
21383           case MOD:
21384           case MODE:
21385           case MONTH:
21386           case NATURAL:
21387           case NATURALN:
21388           case NEW:
21389           case NEXTVAL:
21390           case NO:
21391           case NOCOPY:
21392           case NONEDITIONABLE:
21393           case NOT:
21394           case NOWAIT:
21395           case NULL:
21396           case NULLIF:
21397           case NUMBER:
21398           case BFILE_BASE:
21399           case BLOB_BASE:
21400           case CLOB_BASE:
21401           case DATE_BASE:
21402           case NUMBER_BASE:
21403           case OBJECT:
21404           case OCIROWID:
21405           case OF:
21406           case OID:
21407           case ON:
21408           case OPAQUE:
21409           case OPEN:
21410           case OPERATOR:
21411           case OPTION:
21412           case OR:
21413           case ORDER:
21414           case ORGANIZATION:
21415           case OTHERS:
21416           case OUT:
21417           case OVERRIDING:
21418           case PACKAGE:
21419           case PARTITION:
21420           case PCTFREE:
21421           case PLS_INTEGER:
21422           case POSITIVE:
21423           case POSITIVEN:
21424           case PRESERVE:
21425           case PRIOR:
21426           case PROMPT:
21427           case PRIVATE:
21428           case PROCEDURE:
21429           case PUBLIC:
21430           case RAISE:
21431           case RANGE:
21432           case RAW:
21433           case REAL:
21434           case RECORD:
21435           case REF:
21436           case RELEASE:
21437           case RELIES_ON:
21438           case RENAME:
21439           case RESULT:
21440           case RETURN:
21441           case RETURNING:
21442           case REVERSE:
21443           case ROLLBACK:
21444           case ROW:
21445           case ROWS:
21446           case ROWID:
21447           case ROWNUM:
21448           case ROWTYPE:
21449           case SAVE:
21450           case SAVEPOINT:
21451           case SECOND:
21452           case SELECT:
21453           case SELF:
21454           case SEPARATE:
21455           case SET:
21456           case SHARE:
21457           case SMALLINT:
21458           case SPACE:
21459           case SQL:
21460           case SQLCODE:
21461           case SQLERRM:
21462           case START:
21463           case STATIC:
21464           case STDDEV:
21465           case SUBTYPE:
21466           case SUBSTITUTABLE:
21467           case SUCCESSFUL:
21468           case SUM:
21469           case SYNONYM:
21470           case SYSDATE:
21471           case SYS_REFCURSOR:
21472           case TABLE:
21473           case TEMPORARY:
21474           case THEN:
21475           case TIME:
21476           case TIMESTAMP:
21477           case TIMEZONE_REGION:
21478           case TIMEZONE_ABBR:
21479           case TIMEZONE_MINUTE:
21480           case TIMEZONE_HOUR:
21481           case TO:
21482           case TRANSACTION:
21483           case TRIGGER:
21484           case TRUE:
21485           case TYPE:
21486           case UI:
21487           case UNDER:
21488           case USING:
21489           case WHILE:
21490           case YES:
21491           case SHOW:
21492           case A:
21493           case UPDATE:
21494           case VARCHAR:
21495           case VARCHAR2:
21496           case DOUBLE:
21497           case DEC:
21498           case PRECISION:
21499           case INT:
21500           case NUMERIC:
21501           case SIGNTYPE:
21502           case NCHAR:
21503           case NVARCHAR2:
21504           case STRING:
21505           case UROWID:
21506           case VARRAY:
21507           case VARYING:
21508           case BFILE:
21509           case BLOB:
21510           case CLOB:
21511           case NCLOB:
21512           case YEAR:
21513           case LOCAL:
21514           case WITH:
21515           case ZONE:
21516           case CHARACTER:
21517           case AFTER:
21518           case BEFORE:
21519           case OLD:
21520           case PARENT:
21521           case ANALYZE:
21522           case ASSOCIATE:
21523           case AUDIT:
21524           case COMPOUND:
21525           case DATABASE:
21526           case CALL:
21527           case DDL:
21528           case DISASSOCIATE:
21529           case EACH:
21530           case FOLLOWS:
21531           case LOGOFF:
21532           case LOGON:
21533           case NESTED:
21534           case NOAUDIT:
21535           case SCHEMA:
21536           case SERVERERROR:
21537           case SHUTDOWN:
21538           case STARTUP:
21539           case STATEMENT:
21540           case STATISTICS:
21541           case SUSPEND:
21542           case TRUNCATE:
21543           case WRAPPED:
21544           case LIBRARY:
21545           case NAME:
21546           case STRUCT:
21547           case CONTEXT:
21548           case PARAMETERS:
21549           case LENGTH:
21550           case TDO:
21551           case MAXLEN:
21552           case CHARSETID:
21553           case CHARSETFORM:
21554           case ACCEPT:
21555           case ACCESSIBLE:
21556           case COPY:
21557           case DEFINE:
21558           case DISCONNECT:
21559           case HOST:
21560           case PRINT:
21561           case QUIT:
21562           case REMARK:
21563           case UNDEFINE:
21564           case VARIABLE:
21565           case WHENEVER:
21566           case ATTACH:
21567           case CAST:
21568           case TREAT:
21569           case TRIM:
21570           case LEFT:
21571           case RIGHT:
21572           case BOTH:
21573           case EMPTY:
21574           case MULTISET:
21575           case SUBMULTISET:
21576           case LEADING:
21577           case TRAILING:
21578           case CHAR_CS:
21579           case NCHAR_CS:
21580           case DBTIMEZONE:
21581           case SESSIONTIMEZONE:
21582           case AUTHENTICATED:
21583           case LINK:
21584           case SHARED:
21585           case DIRECTORY:
21586           case USER:
21587           case IDENTIFIER:
21588           case QUOTED_LITERAL:
21589           case SQLDATA_CLASS:
21590           case CUSTOMDATUM_CLASS:
21591           case ORADATA_CLASS:
21592           case JAVA_INTERFACE_CLASS:
21593             ID();
21594             break;
21595           case STRING_LITERAL:
21596             StringLiteral();
21597             break;
21598           default:
21599             jj_la1[279] = jj_gen;
21600             jj_consume_token(-1);
21601             throw new ParseException();
21602           }
21603           switch (jj_nt.kind) {
21604           case 6:
21605             ;
21606             break;
21607           default:
21608             jj_la1[280] = jj_gen;
21609             break label_67;
21610           }
21611         }
21612         jj_consume_token(7);
21613         break;
21614       case EXCEPTION_INIT:
21615         jj_consume_token(EXCEPTION_INIT);
21616         jj_consume_token(5);
21617         jj_consume_token(IDENTIFIER);
21618         jj_consume_token(6);
21619         switch (jj_nt.kind) {
21620         case 16:
21621         case 17:
21622           switch (jj_nt.kind) {
21623           case 16:
21624             jj_consume_token(16);
21625             break;
21626           case 17:
21627             jj_consume_token(17);
21628             break;
21629           default:
21630             jj_la1[281] = jj_gen;
21631             jj_consume_token(-1);
21632             throw new ParseException();
21633           }
21634           break;
21635         default:
21636           jj_la1[282] = jj_gen;
21637           ;
21638         }
21639         NumericLiteral();
21640         jj_consume_token(7);
21641         break;
21642       case INTERFACE:
21643         jj_consume_token(INTERFACE);
21644         jj_consume_token(5);
21645         jj_consume_token(IDENTIFIER);
21646         jj_consume_token(6);
21647         ID();
21648         switch (jj_nt.kind) {
21649         case 6:
21650           jj_consume_token(6);
21651           NumericLiteral();
21652           break;
21653         default:
21654           jj_la1[283] = jj_gen;
21655           ;
21656         }
21657         jj_consume_token(7);
21658         break;
21659       case REPLACE:
21660       case DEFINER:
21661       case CURRENT_USER:
21662       case LANGUAGE:
21663       case INLINE:
21664       case ADD:
21665       case AGGREGATE:
21666       case ARRAY:
21667       case AT:
21668       case ATTRIBUTE:
21669       case AUTHID:
21670       case BODY:
21671       case BULK:
21672       case BYTE:
21673       case CASCADE:
21674       case CLOSE:
21675       case COALESCE:
21676       case COLLECT:
21677       case COLUMN:
21678       case COMMENT:
21679       case COMMIT:
21680       case CONSTRUCTOR:
21681       case CONTINUE:
21682       case CONVERT:
21683       case CURRENT:
21684       case CURSOR:
21685       case DATA:
21686       case DAY:
21687       case DISABLE:
21688       case EDITIONABLE:
21689       case ELEMENT:
21690       case ENABLE:
21691       case ESCAPE:
21692       case EXCEPT:
21693       case EXCEPTIONS:
21694       case EXIT:
21695       case EXTERNAL:
21696       case EXTENDS:
21697       case EXTRACT:
21698       case FALSE:
21699       case FINAL:
21700       case FORCE:
21701       case FUNCTION:
21702       case GLOBAL:
21703       case HASH:
21704       case HEAP:
21705       case HOUR:
21706       case IMMEDIATE:
21707       case INDICES:
21708       case INDEXTYPE:
21709       case INDICATOR:
21710       case INSTANTIABLE:
21711       case INTERVAL:
21712       case INVALIDATE:
21713       case ISOLATION:
21714       case JAVA:
21715       case LEVEL:
21716       case LIMIT:
21717       case LOOP:
21718       case MAP:
21719       case MAX:
21720       case MEMBER:
21721       case MERGE:
21722       case MIN:
21723       case MINUTE:
21724       case MLSLABEL:
21725       case MODIFY:
21726       case MOD:
21727       case MONTH:
21728       case NATURAL:
21729       case NEW:
21730       case NO:
21731       case NONEDITIONABLE:
21732       case NULLIF:
21733       case OBJECT:
21734       case OID:
21735       case OPAQUE:
21736       case OPEN:
21737       case OPERATOR:
21738       case ORGANIZATION:
21739       case OTHERS:
21740       case OVERRIDING:
21741       case PACKAGE:
21742       case PARTITION:
21743       case PRESERVE:
21744       case PRIVATE:
21745       case PROCEDURE:
21746       case RANGE:
21747       case RAW:
21748       case REAL:
21749       case RECORD:
21750       case REF:
21751       case RELEASE:
21752       case RELIES_ON:
21753       case RENAME:
21754       case RESULT:
21755       case RETURN:
21756       case RETURNING:
21757       case REVERSE:
21758       case ROLLBACK:
21759       case ROW:
21760       case ROWS:
21761       case ROWID:
21762       case ROWNUM:
21763       case SAVE:
21764       case SAVEPOINT:
21765       case SECOND:
21766       case SELF:
21767       case SET:
21768       case SPACE:
21769       case SQL:
21770       case SQLCODE:
21771       case SQLERRM:
21772       case STATIC:
21773       case SUBTYPE:
21774       case SUBSTITUTABLE:
21775       case SUCCESSFUL:
21776       case SYSDATE:
21777       case SYS_REFCURSOR:
21778       case TEMPORARY:
21779       case TIME:
21780       case TIMEZONE_REGION:
21781       case TIMEZONE_ABBR:
21782       case TIMEZONE_MINUTE:
21783       case TIMEZONE_HOUR:
21784       case TRANSACTION:
21785       case TRUE:
21786       case TYPE:
21787       case UNDER:
21788       case USING:
21789       case YES:
21790       case SHOW:
21791       case A:
21792       case DOUBLE:
21793       case DEC:
21794       case PRECISION:
21795       case INT:
21796       case NUMERIC:
21797       case NCHAR:
21798       case NVARCHAR2:
21799       case STRING:
21800       case UROWID:
21801       case VARRAY:
21802       case VARYING:
21803       case BFILE:
21804       case BLOB:
21805       case CLOB:
21806       case NCLOB:
21807       case YEAR:
21808       case LOCAL:
21809       case ZONE:
21810       case CHARACTER:
21811       case AFTER:
21812       case BEFORE:
21813       case OLD:
21814       case PARENT:
21815       case ANALYZE:
21816       case ASSOCIATE:
21817       case AUDIT:
21818       case COMPOUND:
21819       case DATABASE:
21820       case CALL:
21821       case DDL:
21822       case DISASSOCIATE:
21823       case EACH:
21824       case FOLLOWS:
21825       case LOGOFF:
21826       case LOGON:
21827       case NESTED:
21828       case NOAUDIT:
21829       case SCHEMA:
21830       case SERVERERROR:
21831       case SHUTDOWN:
21832       case STARTUP:
21833       case STATEMENT:
21834       case STATISTICS:
21835       case SUSPEND:
21836       case TRUNCATE:
21837       case WRAPPED:
21838       case LIBRARY:
21839       case NAME:
21840       case STRUCT:
21841       case CONTEXT:
21842       case PARAMETERS:
21843       case LENGTH:
21844       case TDO:
21845       case MAXLEN:
21846       case CHARSETID:
21847       case CHARSETFORM:
21848       case ACCEPT:
21849       case ACCESSIBLE:
21850       case COPY:
21851       case DEFINE:
21852       case DISCONNECT:
21853       case HOST:
21854       case PRINT:
21855       case QUIT:
21856       case REMARK:
21857       case UNDEFINE:
21858       case VARIABLE:
21859       case WHENEVER:
21860       case ATTACH:
21861       case CAST:
21862       case TREAT:
21863       case TRIM:
21864       case LEFT:
21865       case RIGHT:
21866       case BOTH:
21867       case EMPTY:
21868       case MULTISET:
21869       case SUBMULTISET:
21870       case LEADING:
21871       case TRAILING:
21872       case CHAR_CS:
21873       case NCHAR_CS:
21874       case DBTIMEZONE:
21875       case SESSIONTIMEZONE:
21876       case AUTHENTICATED:
21877       case LINK:
21878       case SHARED:
21879       case DIRECTORY:
21880       case USER:
21881       case IDENTIFIER:
21882       case QUOTED_LITERAL:
21883         QualifiedName();
21884         jj_consume_token(5);
21885         ReadPastNextOccurrence(")");
21886         break;
21887       default:
21888         jj_la1[284] = jj_gen;
21889         jj_consume_token(-1);
21890         throw new ParseException();
21891       }
21892       jj_consume_token(4);
21893         jjtree.closeNodeScope(jjtn000, true);
21894         jjtc000 = false;
21895         {if (true) return jjtn000 ;}
21896     } catch (Throwable jjte000) {
21897           if (jjtc000) {
21898             jjtree.clearNodeScope(jjtn000);
21899             jjtc000 = false;
21900           } else {
21901             jjtree.popNode();
21902           }
21903           if (jjte000 instanceof RuntimeException) {
21904             {if (true) throw (RuntimeException)jjte000;}
21905           }
21906           if (jjte000 instanceof ParseException) {
21907             {if (true) throw (ParseException)jjte000;}
21908           }
21909           {if (true) throw (Error)jjte000;}
21910     } finally {
21911           if (jjtc000) {
21912             jjtree.closeNodeScope(jjtn000, true);
21913           }
21914     }
21915     throw new Error("Missing return statement in function");
21916   }
21917 
21918   final public ASTInlinePragma InlinePragma() throws ParseException {
21919  /*@bgen(jjtree) InlinePragma */
21920   ASTInlinePragma jjtn000 = new ASTInlinePragma(this, JJTINLINEPRAGMA);
21921   boolean jjtc000 = true;
21922   jjtree.openNodeScope(jjtn000);
21923     try {
21924       jj_consume_token(PRAGMA);
21925       jj_consume_token(INLINE);
21926       jj_consume_token(5);
21927       QualifiedName();
21928       jj_consume_token(6);
21929       StringLiteral();
21930       jj_consume_token(7);
21931         jjtree.closeNodeScope(jjtn000, true);
21932         jjtc000 = false;
21933         {if (true) return jjtn000 ;}
21934     } catch (Throwable jjte000) {
21935           if (jjtc000) {
21936             jjtree.clearNodeScope(jjtn000);
21937             jjtc000 = false;
21938           } else {
21939             jjtree.popNode();
21940           }
21941           if (jjte000 instanceof RuntimeException) {
21942             {if (true) throw (RuntimeException)jjte000;}
21943           }
21944           if (jjte000 instanceof ParseException) {
21945             {if (true) throw (ParseException)jjte000;}
21946           }
21947           {if (true) throw (Error)jjte000;}
21948     } finally {
21949           if (jjtc000) {
21950             jjtree.closeNodeScope(jjtn000, true);
21951           }
21952     }
21953     throw new Error("Missing return statement in function");
21954   }
21955 
21956   final public ASTExceptionDeclaration ExceptionDeclaration() throws ParseException {
21957  /*@bgen(jjtree) ExceptionDeclaration */
21958  ASTExceptionDeclaration jjtn000 = new ASTExceptionDeclaration(this, JJTEXCEPTIONDECLARATION);
21959  boolean jjtc000 = true;
21960  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21961     try {
21962       simpleNode = ID();
21963       jj_consume_token(EXCEPTION);
21964       jj_consume_token(4);
21965         jjtree.closeNodeScope(jjtn000, true);
21966         jjtc000 = false;
21967         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
21968     } catch (Throwable jjte000) {
21969           if (jjtc000) {
21970             jjtree.clearNodeScope(jjtn000);
21971             jjtc000 = false;
21972           } else {
21973             jjtree.popNode();
21974           }
21975           if (jjte000 instanceof RuntimeException) {
21976             {if (true) throw (RuntimeException)jjte000;}
21977           }
21978           if (jjte000 instanceof ParseException) {
21979             {if (true) throw (ParseException)jjte000;}
21980           }
21981           {if (true) throw (Error)jjte000;}
21982     } finally {
21983           if (jjtc000) {
21984             jjtree.closeNodeScope(jjtn000, true);
21985           }
21986     }
21987     throw new Error("Missing return statement in function");
21988   }
21989 
21990   final public ASTParallelClause ParallelClause() throws ParseException {
21991  /*@bgen(jjtree) ParallelClause */
21992   ASTParallelClause jjtn000 = new ASTParallelClause(this, JJTPARALLELCLAUSE);
21993   boolean jjtc000 = true;
21994   jjtree.openNodeScope(jjtn000);
21995     try {
21996       jj_consume_token(5);
21997       jj_consume_token(PARTITION);
21998       ID();
21999       jj_consume_token(BY);
22000       switch (jj_nt.kind) {
22001       case ANY:
22002         jj_consume_token(ANY);
22003         break;
22004       case HASH:
22005       case RANGE:
22006         switch (jj_nt.kind) {
22007         case HASH:
22008           jj_consume_token(HASH);
22009           break;
22010         case RANGE:
22011           jj_consume_token(RANGE);
22012           break;
22013         default:
22014           jj_la1[285] = jj_gen;
22015           jj_consume_token(-1);
22016           throw new ParseException();
22017         }
22018         jj_consume_token(5);
22019         ID();
22020         label_68:
22021         while (true) {
22022           switch (jj_nt.kind) {
22023           case 6:
22024             ;
22025             break;
22026           default:
22027             jj_la1[286] = jj_gen;
22028             break label_68;
22029           }
22030           jj_consume_token(6);
22031           ID();
22032         }
22033         jj_consume_token(7);
22034         break;
22035       default:
22036         jj_la1[287] = jj_gen;
22037         jj_consume_token(-1);
22038         throw new ParseException();
22039       }
22040       jj_consume_token(7);
22041       switch (jj_nt.kind) {
22042       case CLUSTER:
22043       case ORDER:
22044         switch (jj_nt.kind) {
22045         case ORDER:
22046           jj_consume_token(ORDER);
22047           break;
22048         case CLUSTER:
22049           jj_consume_token(CLUSTER);
22050           break;
22051         default:
22052           jj_la1[288] = jj_gen;
22053           jj_consume_token(-1);
22054           throw new ParseException();
22055         }
22056         jj_consume_token(BY);
22057         jj_consume_token(5);
22058         ID();
22059         label_69:
22060         while (true) {
22061           switch (jj_nt.kind) {
22062           case 6:
22063             ;
22064             break;
22065           default:
22066             jj_la1[289] = jj_gen;
22067             break label_69;
22068           }
22069           jj_consume_token(6);
22070           ID();
22071         }
22072         jj_consume_token(7);
22073         break;
22074       default:
22075         jj_la1[290] = jj_gen;
22076         ;
22077       }
22078         jjtree.closeNodeScope(jjtn000, true);
22079         jjtc000 = false;
22080         {if (true) return jjtn000 ;}
22081     } catch (Throwable jjte000) {
22082       if (jjtc000) {
22083         jjtree.clearNodeScope(jjtn000);
22084         jjtc000 = false;
22085       } else {
22086         jjtree.popNode();
22087       }
22088       if (jjte000 instanceof RuntimeException) {
22089         {if (true) throw (RuntimeException)jjte000;}
22090       }
22091       if (jjte000 instanceof ParseException) {
22092         {if (true) throw (ParseException)jjte000;}
22093       }
22094       {if (true) throw (Error)jjte000;}
22095     } finally {
22096       if (jjtc000) {
22097         jjtree.closeNodeScope(jjtn000, true);
22098       }
22099     }
22100     throw new Error("Missing return statement in function");
22101   }
22102 
22103   final public ASTAccessibleByClause AccessibleByClause() throws ParseException {
22104  /*@bgen(jjtree) AccessibleByClause */
22105   ASTAccessibleByClause jjtn000 = new ASTAccessibleByClause(this, JJTACCESSIBLEBYCLAUSE);
22106   boolean jjtc000 = true;
22107   jjtree.openNodeScope(jjtn000);
22108     try {
22109       jj_consume_token(ACCESSIBLE);
22110       jj_consume_token(BY);
22111       jj_consume_token(5);
22112       switch (jj_nt.kind) {
22113       case FUNCTION:
22114       case PACKAGE:
22115       case PROCEDURE:
22116       case TRIGGER:
22117       case TYPE:
22118         switch (jj_nt.kind) {
22119         case FUNCTION:
22120           jj_consume_token(FUNCTION);
22121           break;
22122         case PROCEDURE:
22123           jj_consume_token(PROCEDURE);
22124           break;
22125         case PACKAGE:
22126           jj_consume_token(PACKAGE);
22127           break;
22128         case TRIGGER:
22129           jj_consume_token(TRIGGER);
22130           break;
22131         case TYPE:
22132           jj_consume_token(TYPE);
22133           break;
22134         default:
22135           jj_la1[291] = jj_gen;
22136           jj_consume_token(-1);
22137           throw new ParseException();
22138         }
22139         break;
22140       default:
22141         jj_la1[292] = jj_gen;
22142         ;
22143       }
22144       QualifiedName();
22145       label_70:
22146       while (true) {
22147         switch (jj_nt.kind) {
22148         case 6:
22149           ;
22150           break;
22151         default:
22152           jj_la1[293] = jj_gen;
22153           break label_70;
22154         }
22155         jj_consume_token(6);
22156         switch (jj_nt.kind) {
22157         case FUNCTION:
22158         case PACKAGE:
22159         case PROCEDURE:
22160         case TRIGGER:
22161         case TYPE:
22162           switch (jj_nt.kind) {
22163           case FUNCTION:
22164             jj_consume_token(FUNCTION);
22165             break;
22166           case PROCEDURE:
22167             jj_consume_token(PROCEDURE);
22168             break;
22169           case PACKAGE:
22170             jj_consume_token(PACKAGE);
22171             break;
22172           case TRIGGER:
22173             jj_consume_token(TRIGGER);
22174             break;
22175           case TYPE:
22176             jj_consume_token(TYPE);
22177             break;
22178           default:
22179             jj_la1[294] = jj_gen;
22180             jj_consume_token(-1);
22181             throw new ParseException();
22182           }
22183           break;
22184         default:
22185           jj_la1[295] = jj_gen;
22186           ;
22187         }
22188         QualifiedName();
22189       }
22190       jj_consume_token(7);
22191         jjtree.closeNodeScope(jjtn000, true);
22192         jjtc000 = false;
22193         {if (true) return jjtn000 ;}
22194     } catch (Throwable jjte000) {
22195       if (jjtc000) {
22196         jjtree.clearNodeScope(jjtn000);
22197         jjtc000 = false;
22198       } else {
22199         jjtree.popNode();
22200       }
22201       if (jjte000 instanceof RuntimeException) {
22202         {if (true) throw (RuntimeException)jjte000;}
22203       }
22204       if (jjte000 instanceof ParseException) {
22205         {if (true) throw (ParseException)jjte000;}
22206       }
22207       {if (true) throw (Error)jjte000;}
22208     } finally {
22209       if (jjtc000) {
22210         jjtree.closeNodeScope(jjtn000, true);
22211       }
22212     }
22213     throw new Error("Missing return statement in function");
22214   }
22215 
22216 // Copyright (C) 2002 Albert Tumanov
22217 
22218 /**
22219  * 2006-05-10 - Matthias Hendler - merged SIV and sourceforge sources
22220  */
22221 
22222 // SRT *
22223   final public ASTTable Table() throws ParseException {
22224  /*@bgen(jjtree) Table */
22225   ASTTable jjtn000 = new ASTTable(this, JJTTABLE);
22226   boolean jjtc000 = true;
22227   jjtree.openNodeScope(jjtn000);
22228     try {
22229       jj_consume_token(CREATE);
22230       switch (jj_nt.kind) {
22231       case GLOBAL:
22232         jj_consume_token(GLOBAL);
22233         jj_consume_token(TEMPORARY);
22234         break;
22235       default:
22236         jj_la1[296] = jj_gen;
22237         ;
22238       }
22239       jj_consume_token(TABLE);
22240       ObjectNameDeclaration();
22241       jj_consume_token(5);
22242       TableColumn();
22243       label_71:
22244       while (true) {
22245         switch (jj_nt.kind) {
22246         case 6:
22247           ;
22248           break;
22249         default:
22250           jj_la1[297] = jj_gen;
22251           break label_71;
22252         }
22253         jj_consume_token(6);
22254         TableColumn();
22255       }
22256       jj_consume_token(7);
22257       if (jj_2_59(2)) {
22258         jj_consume_token(ON);
22259         jj_consume_token(COMMIT);
22260         switch (jj_nt.kind) {
22261         case DELETE:
22262           jj_consume_token(DELETE);
22263           break;
22264         case PRESERVE:
22265           jj_consume_token(PRESERVE);
22266           break;
22267         default:
22268           jj_la1[298] = jj_gen;
22269           jj_consume_token(-1);
22270           throw new ParseException();
22271         }
22272         jj_consume_token(ROWS);
22273       } else {
22274         ;
22275       }
22276       switch (jj_nt.kind) {
22277       case 4:
22278         jj_consume_token(4);
22279         break;
22280       default:
22281         jj_la1[299] = jj_gen;
22282         ;
22283       }
22284         jjtree.closeNodeScope(jjtn000, true);
22285         jjtc000 = false;
22286         {if (true) return jjtn000 ;}
22287     } catch (Throwable jjte000) {
22288     if (jjtc000) {
22289       jjtree.clearNodeScope(jjtn000);
22290       jjtc000 = false;
22291     } else {
22292       jjtree.popNode();
22293     }
22294     if (jjte000 instanceof RuntimeException) {
22295       {if (true) throw (RuntimeException)jjte000;}
22296     }
22297     if (jjte000 instanceof ParseException) {
22298       {if (true) throw (ParseException)jjte000;}
22299     }
22300     {if (true) throw (Error)jjte000;}
22301     } finally {
22302     if (jjtc000) {
22303       jjtree.closeNodeScope(jjtn000, true);
22304     }
22305     }
22306     throw new Error("Missing return statement in function");
22307   }
22308 
22309   final public ASTTableColumn TableColumn() throws ParseException {
22310  /*@bgen(jjtree) TableColumn */
22311   ASTTableColumn jjtn000 = new ASTTableColumn(this, JJTTABLECOLUMN);
22312   boolean jjtc000 = true;
22313   jjtree.openNodeScope(jjtn000);
22314     try {
22315       ID();
22316       Datatype();
22317       switch (jj_nt.kind) {
22318       case _DEFAULT:
22319         jj_consume_token(_DEFAULT);
22320         Expression();
22321         break;
22322       default:
22323         jj_la1[300] = jj_gen;
22324         ;
22325       }
22326       switch (jj_nt.kind) {
22327       case NOT:
22328       case NULL:
22329         switch (jj_nt.kind) {
22330         case NOT:
22331           jj_consume_token(NOT);
22332           break;
22333         default:
22334           jj_la1[301] = jj_gen;
22335           ;
22336         }
22337         jj_consume_token(NULL);
22338         break;
22339       default:
22340         jj_la1[302] = jj_gen;
22341         ;
22342       }
22343         jjtree.closeNodeScope(jjtn000, true);
22344         jjtc000 = false;
22345         {if (true) return jjtn000 ;}
22346     } catch (Throwable jjte000) {
22347     if (jjtc000) {
22348       jjtree.clearNodeScope(jjtn000);
22349       jjtc000 = false;
22350     } else {
22351       jjtree.popNode();
22352     }
22353     if (jjte000 instanceof RuntimeException) {
22354       {if (true) throw (RuntimeException)jjte000;}
22355     }
22356     if (jjte000 instanceof ParseException) {
22357       {if (true) throw (ParseException)jjte000;}
22358     }
22359     {if (true) throw (Error)jjte000;}
22360     } finally {
22361     if (jjtc000) {
22362       jjtree.closeNodeScope(jjtn000, true);
22363     }
22364     }
22365     throw new Error("Missing return statement in function");
22366   }
22367 
22368   final public ASTView View() throws ParseException {
22369  /*@bgen(jjtree) View */
22370  ASTView jjtn000 = new ASTView(this, JJTVIEW);
22371  boolean jjtc000 = true;
22372  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22373     try {
22374       jj_consume_token(CREATE);
22375       switch (jj_nt.kind) {
22376       case OR:
22377         jj_consume_token(OR);
22378         jj_consume_token(REPLACE);
22379         break;
22380       default:
22381         jj_la1[303] = jj_gen;
22382         ;
22383       }
22384       switch (jj_nt.kind) {
22385       case FORCE:
22386       case NO:
22387         switch (jj_nt.kind) {
22388         case NO:
22389           jj_consume_token(NO);
22390           break;
22391         default:
22392           jj_la1[304] = jj_gen;
22393           ;
22394         }
22395         jj_consume_token(FORCE);
22396         break;
22397       default:
22398         jj_la1[305] = jj_gen;
22399         ;
22400       }
22401       jj_consume_token(VIEW);
22402       simpleNode = ObjectNameDeclaration();
22403       switch (jj_nt.kind) {
22404       case 5:
22405         jj_consume_token(5);
22406         ViewColumn();
22407         label_72:
22408         while (true) {
22409           switch (jj_nt.kind) {
22410           case 6:
22411             ;
22412             break;
22413           default:
22414             jj_la1[306] = jj_gen;
22415             break label_72;
22416           }
22417           jj_consume_token(6);
22418           ViewColumn();
22419         }
22420         jj_consume_token(7);
22421         break;
22422       default:
22423         jj_la1[307] = jj_gen;
22424         ;
22425       }
22426       jj_consume_token(AS);
22427       Statement();
22428       switch (jj_nt.kind) {
22429       case 4:
22430         jj_consume_token(4);
22431         break;
22432       case 1:
22433         jj_consume_token(1);
22434         break;
22435       default:
22436         jj_la1[308] = jj_gen;
22437         jj_consume_token(-1);
22438         throw new ParseException();
22439       }
22440     jjtree.closeNodeScope(jjtn000, true);
22441     jjtc000 = false;
22442     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
22443     } catch (Throwable jjte000) {
22444     if (jjtc000) {
22445       jjtree.clearNodeScope(jjtn000);
22446       jjtc000 = false;
22447     } else {
22448       jjtree.popNode();
22449     }
22450     if (jjte000 instanceof RuntimeException) {
22451       {if (true) throw (RuntimeException)jjte000;}
22452     }
22453     if (jjte000 instanceof ParseException) {
22454       {if (true) throw (ParseException)jjte000;}
22455     }
22456     {if (true) throw (Error)jjte000;}
22457     } finally {
22458     if (jjtc000) {
22459       jjtree.closeNodeScope(jjtn000, true);
22460     }
22461     }
22462     throw new Error("Missing return statement in function");
22463   }
22464 
22465   final public ASTSynonym Synonym() throws ParseException {
22466  /*@bgen(jjtree) Synonym */
22467  ASTSynonym jjtn000 = new ASTSynonym(this, JJTSYNONYM);
22468  boolean jjtc000 = true;
22469  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22470     try {
22471       jj_consume_token(CREATE);
22472       switch (jj_nt.kind) {
22473       case OR:
22474         jj_consume_token(OR);
22475         jj_consume_token(REPLACE);
22476         break;
22477       default:
22478         jj_la1[309] = jj_gen;
22479         ;
22480       }
22481       switch (jj_nt.kind) {
22482       case PUBLIC:
22483         jj_consume_token(PUBLIC);
22484         break;
22485       default:
22486         jj_la1[310] = jj_gen;
22487         ;
22488       }
22489       jj_consume_token(SYNONYM);
22490       simpleNode = ObjectNameDeclaration();
22491       jj_consume_token(FOR);
22492       ObjectNameDeclaration();
22493       switch (jj_nt.kind) {
22494       case 4:
22495         jj_consume_token(4);
22496         break;
22497       case 1:
22498         jj_consume_token(1);
22499         break;
22500       default:
22501         jj_la1[311] = jj_gen;
22502         jj_consume_token(-1);
22503         throw new ParseException();
22504       }
22505     jjtree.closeNodeScope(jjtn000, true);
22506     jjtc000 = false;
22507     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
22508     } catch (Throwable jjte000) {
22509     if (jjtc000) {
22510       jjtree.clearNodeScope(jjtn000);
22511       jjtc000 = false;
22512     } else {
22513       jjtree.popNode();
22514     }
22515     if (jjte000 instanceof RuntimeException) {
22516       {if (true) throw (RuntimeException)jjte000;}
22517     }
22518     if (jjte000 instanceof ParseException) {
22519       {if (true) throw (ParseException)jjte000;}
22520     }
22521     {if (true) throw (Error)jjte000;}
22522     } finally {
22523     if (jjtc000) {
22524       jjtree.closeNodeScope(jjtn000, true);
22525     }
22526     }
22527     throw new Error("Missing return statement in function");
22528   }
22529 
22530   final public ASTDirectory Directory() throws ParseException {
22531  /*@bgen(jjtree) Directory */
22532  ASTDirectory jjtn000 = new ASTDirectory(this, JJTDIRECTORY);
22533  boolean jjtc000 = true;
22534  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22535     try {
22536       jj_consume_token(CREATE);
22537       switch (jj_nt.kind) {
22538       case OR:
22539         jj_consume_token(OR);
22540         jj_consume_token(REPLACE);
22541         break;
22542       default:
22543         jj_la1[312] = jj_gen;
22544         ;
22545       }
22546       jj_consume_token(DIRECTORY);
22547       simpleNode = ObjectNameDeclaration();
22548       jj_consume_token(AS);
22549       StringLiteral();
22550       switch (jj_nt.kind) {
22551       case 4:
22552         jj_consume_token(4);
22553         break;
22554       case 1:
22555         jj_consume_token(1);
22556         break;
22557       default:
22558         jj_la1[313] = jj_gen;
22559         jj_consume_token(-1);
22560         throw new ParseException();
22561       }
22562     jjtree.closeNodeScope(jjtn000, true);
22563     jjtc000 = false;
22564     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
22565     } catch (Throwable jjte000) {
22566     if (jjtc000) {
22567       jjtree.clearNodeScope(jjtn000);
22568       jjtc000 = false;
22569     } else {
22570       jjtree.popNode();
22571     }
22572     if (jjte000 instanceof RuntimeException) {
22573       {if (true) throw (RuntimeException)jjte000;}
22574     }
22575     if (jjte000 instanceof ParseException) {
22576       {if (true) throw (ParseException)jjte000;}
22577     }
22578     {if (true) throw (Error)jjte000;}
22579     } finally {
22580     if (jjtc000) {
22581       jjtree.closeNodeScope(jjtn000, true);
22582     }
22583     }
22584     throw new Error("Missing return statement in function");
22585   }
22586 
22587   final public ASTDatabaseLink DatabaseLink() throws ParseException {
22588  /*@bgen(jjtree) DatabaseLink */
22589  ASTDatabaseLink jjtn000 = new ASTDatabaseLink(this, JJTDATABASELINK);
22590  boolean jjtc000 = true;
22591  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22592     try {
22593       jj_consume_token(CREATE);
22594       switch (jj_nt.kind) {
22595       case SHARED:
22596         jj_consume_token(SHARED);
22597         break;
22598       default:
22599         jj_la1[314] = jj_gen;
22600         ;
22601       }
22602       switch (jj_nt.kind) {
22603       case PUBLIC:
22604         jj_consume_token(PUBLIC);
22605         break;
22606       default:
22607         jj_la1[315] = jj_gen;
22608         ;
22609       }
22610       jj_consume_token(DATABASE);
22611       jj_consume_token(LINK);
22612       simpleNode = ObjectNameDeclaration();
22613       switch (jj_nt.kind) {
22614       case CONNECT:
22615         jj_consume_token(CONNECT);
22616         jj_consume_token(TO);
22617         switch (jj_nt.kind) {
22618         case CURRENT_USER:
22619           jj_consume_token(CURRENT_USER);
22620           break;
22621         case REPLACE:
22622         case DEFINER:
22623         case LANGUAGE:
22624         case INLINE:
22625         case ADD:
22626         case AGGREGATE:
22627         case ARRAY:
22628         case AT:
22629         case ATTRIBUTE:
22630         case AUTHID:
22631         case BODY:
22632         case BULK:
22633         case BYTE:
22634         case CASCADE:
22635         case CLOSE:
22636         case COALESCE:
22637         case COLLECT:
22638         case COLUMN:
22639         case COMMENT:
22640         case COMMIT:
22641         case CONSTRUCTOR:
22642         case CONTINUE:
22643         case CONVERT:
22644         case CURRENT:
22645         case CURSOR:
22646         case DATA:
22647         case DAY:
22648         case DISABLE:
22649         case EDITIONABLE:
22650         case ELEMENT:
22651         case ENABLE:
22652         case ESCAPE:
22653         case EXCEPT:
22654         case EXCEPTIONS:
22655         case EXIT:
22656         case EXTERNAL:
22657         case EXTENDS:
22658         case EXTRACT:
22659         case FALSE:
22660         case FINAL:
22661         case FORCE:
22662         case FUNCTION:
22663         case GLOBAL:
22664         case HASH:
22665         case HEAP:
22666         case HOUR:
22667         case IMMEDIATE:
22668         case INDICES:
22669         case INDEXTYPE:
22670         case INDICATOR:
22671         case INSTANTIABLE:
22672         case INTERVAL:
22673         case INVALIDATE:
22674         case ISOLATION:
22675         case JAVA:
22676         case LEVEL:
22677         case LIMIT:
22678         case LOOP:
22679         case MAP:
22680         case MAX:
22681         case MEMBER:
22682         case MERGE:
22683         case MIN:
22684         case MINUTE:
22685         case MLSLABEL:
22686         case MODIFY:
22687         case MOD:
22688         case MONTH:
22689         case NATURAL:
22690         case NEW:
22691         case NO:
22692         case NONEDITIONABLE:
22693         case NULLIF:
22694         case OBJECT:
22695         case OID:
22696         case OPAQUE:
22697         case OPEN:
22698         case OPERATOR:
22699         case ORGANIZATION:
22700         case OTHERS:
22701         case OVERRIDING:
22702         case PACKAGE:
22703         case PARTITION:
22704         case PRESERVE:
22705         case PRIVATE:
22706         case PROCEDURE:
22707         case RANGE:
22708         case RAW:
22709         case REAL:
22710         case RECORD:
22711         case REF:
22712         case RELEASE:
22713         case RELIES_ON:
22714         case RENAME:
22715         case RESULT:
22716         case RETURN:
22717         case RETURNING:
22718         case REVERSE:
22719         case ROLLBACK:
22720         case ROW:
22721         case ROWS:
22722         case ROWID:
22723         case ROWNUM:
22724         case SAVE:
22725         case SAVEPOINT:
22726         case SECOND:
22727         case SELF:
22728         case SET:
22729         case SPACE:
22730         case SQL:
22731         case SQLCODE:
22732         case SQLERRM:
22733         case STATIC:
22734         case SUBTYPE:
22735         case SUBSTITUTABLE:
22736         case SUCCESSFUL:
22737         case SYSDATE:
22738         case SYS_REFCURSOR:
22739         case TEMPORARY:
22740         case TIME:
22741         case TIMESTAMP:
22742         case TIMEZONE_REGION:
22743         case TIMEZONE_ABBR:
22744         case TIMEZONE_MINUTE:
22745         case TIMEZONE_HOUR:
22746         case TRANSACTION:
22747         case TRUE:
22748         case TYPE:
22749         case UNDER:
22750         case USING:
22751         case YES:
22752         case SHOW:
22753         case A:
22754         case DOUBLE:
22755         case DEC:
22756         case PRECISION:
22757         case INT:
22758         case NUMERIC:
22759         case NCHAR:
22760         case NVARCHAR2:
22761         case STRING:
22762         case UROWID:
22763         case VARRAY:
22764         case VARYING:
22765         case BFILE:
22766         case BLOB:
22767         case CLOB:
22768         case NCLOB:
22769         case YEAR:
22770         case LOCAL:
22771         case ZONE:
22772         case CHARACTER:
22773         case AFTER:
22774         case BEFORE:
22775         case OLD:
22776         case PARENT:
22777         case ANALYZE:
22778         case ASSOCIATE:
22779         case AUDIT:
22780         case COMPOUND:
22781         case DATABASE:
22782         case CALL:
22783         case DDL:
22784         case DISASSOCIATE:
22785         case EACH:
22786         case FOLLOWS:
22787         case LOGOFF:
22788         case LOGON:
22789         case NESTED:
22790         case NOAUDIT:
22791         case SCHEMA:
22792         case SERVERERROR:
22793         case SHUTDOWN:
22794         case STARTUP:
22795         case STATEMENT:
22796         case STATISTICS:
22797         case SUSPEND:
22798         case TRUNCATE:
22799         case WRAPPED:
22800         case LIBRARY:
22801         case NAME:
22802         case STRUCT:
22803         case CONTEXT:
22804         case PARAMETERS:
22805         case LENGTH:
22806         case TDO:
22807         case MAXLEN:
22808         case CHARSETID:
22809         case CHARSETFORM:
22810         case ACCEPT:
22811         case ACCESSIBLE:
22812         case COPY:
22813         case DEFINE:
22814         case DISCONNECT:
22815         case HOST:
22816         case PRINT:
22817         case QUIT:
22818         case REMARK:
22819         case UNDEFINE:
22820         case VARIABLE:
22821         case WHENEVER:
22822         case ATTACH:
22823         case CAST:
22824         case TREAT:
22825         case TRIM:
22826         case LEFT:
22827         case RIGHT:
22828         case BOTH:
22829         case EMPTY:
22830         case MULTISET:
22831         case SUBMULTISET:
22832         case LEADING:
22833         case TRAILING:
22834         case CHAR_CS:
22835         case NCHAR_CS:
22836         case DBTIMEZONE:
22837         case SESSIONTIMEZONE:
22838         case AUTHENTICATED:
22839         case LINK:
22840         case SHARED:
22841         case DIRECTORY:
22842         case USER:
22843         case IDENTIFIER:
22844         case QUOTED_LITERAL:
22845           UnqualifiedID();
22846           jj_consume_token(IDENTIFIED);
22847           jj_consume_token(BY);
22848           UnqualifiedID();
22849           jj_consume_token(AUTHENTICATED);
22850           jj_consume_token(BY);
22851           UnqualifiedID();
22852           jj_consume_token(IDENTIFIED);
22853           jj_consume_token(BY);
22854           UnqualifiedID();
22855           break;
22856         default:
22857           jj_la1[316] = jj_gen;
22858           jj_consume_token(-1);
22859           throw new ParseException();
22860         }
22861         break;
22862       case REPLACE:
22863       case DEFINER:
22864       case CURRENT_USER:
22865       case LANGUAGE:
22866       case INLINE:
22867       case ADD:
22868       case AGGREGATE:
22869       case ARRAY:
22870       case AT:
22871       case ATTRIBUTE:
22872       case AUTHID:
22873       case BODY:
22874       case BULK:
22875       case BYTE:
22876       case CASCADE:
22877       case CLOSE:
22878       case COALESCE:
22879       case COLLECT:
22880       case COLUMN:
22881       case COMMENT:
22882       case COMMIT:
22883       case CONSTRUCTOR:
22884       case CONTINUE:
22885       case CONVERT:
22886       case CURRENT:
22887       case CURSOR:
22888       case DATA:
22889       case DAY:
22890       case DISABLE:
22891       case EDITIONABLE:
22892       case ELEMENT:
22893       case ENABLE:
22894       case ESCAPE:
22895       case EXCEPT:
22896       case EXCEPTIONS:
22897       case EXIT:
22898       case EXTERNAL:
22899       case EXTENDS:
22900       case EXTRACT:
22901       case FALSE:
22902       case FINAL:
22903       case FORCE:
22904       case FUNCTION:
22905       case GLOBAL:
22906       case HASH:
22907       case HEAP:
22908       case HOUR:
22909       case IMMEDIATE:
22910       case INDICES:
22911       case INDEXTYPE:
22912       case INDICATOR:
22913       case INSTANTIABLE:
22914       case INTERVAL:
22915       case INVALIDATE:
22916       case ISOLATION:
22917       case JAVA:
22918       case LEVEL:
22919       case LIMIT:
22920       case LOOP:
22921       case MAP:
22922       case MAX:
22923       case MEMBER:
22924       case MERGE:
22925       case MIN:
22926       case MINUTE:
22927       case MLSLABEL:
22928       case MODIFY:
22929       case MOD:
22930       case MONTH:
22931       case NATURAL:
22932       case NEW:
22933       case NO:
22934       case NONEDITIONABLE:
22935       case NULLIF:
22936       case OBJECT:
22937       case OID:
22938       case OPAQUE:
22939       case OPEN:
22940       case OPERATOR:
22941       case ORGANIZATION:
22942       case OTHERS:
22943       case OVERRIDING:
22944       case PACKAGE:
22945       case PARTITION:
22946       case PRESERVE:
22947       case PRIVATE:
22948       case PROCEDURE:
22949       case RANGE:
22950       case RAW:
22951       case REAL:
22952       case RECORD:
22953       case REF:
22954       case RELEASE:
22955       case RELIES_ON:
22956       case RENAME:
22957       case RESULT:
22958       case RETURN:
22959       case RETURNING:
22960       case REVERSE:
22961       case ROLLBACK:
22962       case ROW:
22963       case ROWS:
22964       case ROWID:
22965       case ROWNUM:
22966       case SAVE:
22967       case SAVEPOINT:
22968       case SECOND:
22969       case SELF:
22970       case SET:
22971       case SPACE:
22972       case SQL:
22973       case SQLCODE:
22974       case SQLERRM:
22975       case STATIC:
22976       case SUBTYPE:
22977       case SUBSTITUTABLE:
22978       case SUCCESSFUL:
22979       case SYSDATE:
22980       case SYS_REFCURSOR:
22981       case TEMPORARY:
22982       case TIME:
22983       case TIMESTAMP:
22984       case TIMEZONE_REGION:
22985       case TIMEZONE_ABBR:
22986       case TIMEZONE_MINUTE:
22987       case TIMEZONE_HOUR:
22988       case TRANSACTION:
22989       case TRUE:
22990       case TYPE:
22991       case UNDER:
22992       case USING:
22993       case YES:
22994       case SHOW:
22995       case A:
22996       case DOUBLE:
22997       case DEC:
22998       case PRECISION:
22999       case INT:
23000       case NUMERIC:
23001       case NCHAR:
23002       case NVARCHAR2:
23003       case STRING:
23004       case UROWID:
23005       case VARRAY:
23006       case VARYING:
23007       case BFILE:
23008       case BLOB:
23009       case CLOB:
23010       case NCLOB:
23011       case YEAR:
23012       case LOCAL:
23013       case ZONE:
23014       case CHARACTER:
23015       case AFTER:
23016       case BEFORE:
23017       case OLD:
23018       case PARENT:
23019       case ANALYZE:
23020       case ASSOCIATE:
23021       case AUDIT:
23022       case COMPOUND:
23023       case DATABASE:
23024       case CALL:
23025       case DDL:
23026       case DISASSOCIATE:
23027       case EACH:
23028       case FOLLOWS:
23029       case LOGOFF:
23030       case LOGON:
23031       case NESTED:
23032       case NOAUDIT:
23033       case SCHEMA:
23034       case SERVERERROR:
23035       case SHUTDOWN:
23036       case STARTUP:
23037       case STATEMENT:
23038       case STATISTICS:
23039       case SUSPEND:
23040       case TRUNCATE:
23041       case WRAPPED:
23042       case LIBRARY:
23043       case NAME:
23044       case STRUCT:
23045       case CONTEXT:
23046       case PARAMETERS:
23047       case LENGTH:
23048       case TDO:
23049       case MAXLEN:
23050       case CHARSETID:
23051       case CHARSETFORM:
23052       case ACCEPT:
23053       case ACCESSIBLE:
23054       case COPY:
23055       case DEFINE:
23056       case DISCONNECT:
23057       case HOST:
23058       case PRINT:
23059       case QUIT:
23060       case REMARK:
23061       case UNDEFINE:
23062       case VARIABLE:
23063       case WHENEVER:
23064       case ATTACH:
23065       case CAST:
23066       case TREAT:
23067       case TRIM:
23068       case LEFT:
23069       case RIGHT:
23070       case BOTH:
23071       case EMPTY:
23072       case MULTISET:
23073       case SUBMULTISET:
23074       case LEADING:
23075       case TRAILING:
23076       case CHAR_CS:
23077       case NCHAR_CS:
23078       case DBTIMEZONE:
23079       case SESSIONTIMEZONE:
23080       case AUTHENTICATED:
23081       case LINK:
23082       case SHARED:
23083       case DIRECTORY:
23084       case USER:
23085       case IDENTIFIER:
23086       case QUOTED_LITERAL:
23087         UnqualifiedID();
23088         jj_consume_token(IDENTIFIED);
23089         jj_consume_token(BY);
23090         UnqualifiedID();
23091         break;
23092       default:
23093         jj_la1[317] = jj_gen;
23094         jj_consume_token(-1);
23095         throw new ParseException();
23096       }
23097       switch (jj_nt.kind) {
23098       case USING:
23099         jj_consume_token(USING);
23100         StringLiteral();
23101         break;
23102       default:
23103         jj_la1[318] = jj_gen;
23104         ;
23105       }
23106       switch (jj_nt.kind) {
23107       case 4:
23108         jj_consume_token(4);
23109         break;
23110       case 1:
23111         jj_consume_token(1);
23112         break;
23113       default:
23114         jj_la1[319] = jj_gen;
23115         jj_consume_token(-1);
23116         throw new ParseException();
23117       }
23118     jjtree.closeNodeScope(jjtn000, true);
23119     jjtc000 = false;
23120     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
23121     } catch (Throwable jjte000) {
23122     if (jjtc000) {
23123       jjtree.clearNodeScope(jjtn000);
23124       jjtc000 = false;
23125     } else {
23126       jjtree.popNode();
23127     }
23128     if (jjte000 instanceof RuntimeException) {
23129       {if (true) throw (RuntimeException)jjte000;}
23130     }
23131     if (jjte000 instanceof ParseException) {
23132       {if (true) throw (ParseException)jjte000;}
23133     }
23134     {if (true) throw (Error)jjte000;}
23135     } finally {
23136     if (jjtc000) {
23137       jjtree.closeNodeScope(jjtn000, true);
23138     }
23139     }
23140     throw new Error("Missing return statement in function");
23141   }
23142 
23143   final public ASTViewColumn ViewColumn() throws ParseException {
23144  /*@bgen(jjtree) ViewColumn */
23145   ASTViewColumn jjtn000 = new ASTViewColumn(this, JJTVIEWCOLUMN);
23146   boolean jjtc000 = true;
23147   jjtree.openNodeScope(jjtn000);
23148     try {
23149       ID();
23150         jjtree.closeNodeScope(jjtn000, true);
23151         jjtc000 = false;
23152         {if (true) return jjtn000 ;}
23153     } catch (Throwable jjte000) {
23154     if (jjtc000) {
23155       jjtree.clearNodeScope(jjtn000);
23156       jjtc000 = false;
23157     } else {
23158       jjtree.popNode();
23159     }
23160     if (jjte000 instanceof RuntimeException) {
23161       {if (true) throw (RuntimeException)jjte000;}
23162     }
23163     if (jjte000 instanceof ParseException) {
23164       {if (true) throw (ParseException)jjte000;}
23165     }
23166     {if (true) throw (Error)jjte000;}
23167     } finally {
23168     if (jjtc000) {
23169       jjtree.closeNodeScope(jjtn000, true);
23170     }
23171     }
23172     throw new Error("Missing return statement in function");
23173   }
23174 
23175   final public ASTComment Comment() throws ParseException {
23176  /*@bgen(jjtree) Comment */
23177   ASTComment jjtn000 = new ASTComment(this, JJTCOMMENT);
23178   boolean jjtc000 = true;
23179   jjtree.openNodeScope(jjtn000);
23180     try {
23181       jj_consume_token(COMMENT);
23182       jj_consume_token(ON);
23183       switch (jj_nt.kind) {
23184       case INDEXTYPE:
23185       case OPERATOR:
23186       case TABLE:
23187         switch (jj_nt.kind) {
23188         case TABLE:
23189           jj_consume_token(TABLE);
23190           break;
23191         case OPERATOR:
23192           jj_consume_token(OPERATOR);
23193           break;
23194         case INDEXTYPE:
23195           jj_consume_token(INDEXTYPE);
23196           break;
23197         default:
23198           jj_la1[320] = jj_gen;
23199           jj_consume_token(-1);
23200           throw new ParseException();
23201         }
23202         if (jj_2_60(2)) {
23203           ID();
23204           jj_consume_token(3);
23205         } else {
23206           ;
23207         }
23208         ID();
23209         break;
23210       case COLUMN:
23211         jj_consume_token(COLUMN);
23212         if (jj_2_61(2147483647)) {
23213           ID();
23214           jj_consume_token(3);
23215         } else {
23216           ;
23217         }
23218         ID();
23219         jj_consume_token(3);
23220         ID();
23221         break;
23222       default:
23223         jj_la1[321] = jj_gen;
23224         jj_consume_token(-1);
23225         throw new ParseException();
23226       }
23227       jj_consume_token(IS);
23228       jj_consume_token(STRING_LITERAL);
23229       switch (jj_nt.kind) {
23230       case 4:
23231         jj_consume_token(4);
23232         break;
23233       default:
23234         jj_la1[322] = jj_gen;
23235         ;
23236       }
23237         jjtree.closeNodeScope(jjtn000, true);
23238         jjtc000 = false;
23239         {if (true) return jjtn000 ;}
23240     } catch (Throwable jjte000) {
23241     if (jjtc000) {
23242       jjtree.clearNodeScope(jjtn000);
23243       jjtc000 = false;
23244     } else {
23245       jjtree.popNode();
23246     }
23247     if (jjte000 instanceof RuntimeException) {
23248       {if (true) throw (RuntimeException)jjte000;}
23249     }
23250     if (jjte000 instanceof ParseException) {
23251       {if (true) throw (ParseException)jjte000;}
23252     }
23253     {if (true) throw (Error)jjte000;}
23254     } finally {
23255     if (jjtc000) {
23256       jjtree.closeNodeScope(jjtn000, true);
23257     }
23258     }
23259     throw new Error("Missing return statement in function");
23260   }
23261 
23262 // SRT * /
23263   final public ASTTypeMethod TypeMethod() throws ParseException {
23264  /*@bgen(jjtree) TypeMethod */
23265   ASTTypeMethod jjtn000 = new ASTTypeMethod(this, JJTTYPEMETHOD);
23266   boolean jjtc000 = true;
23267   jjtree.openNodeScope(jjtn000);
23268     try {
23269         getToken(1);
23270         //System.err.println("typeMethod: Result of getToken(1) is \"" + startToken.toString() + "\"" );
23271 
23272       label_73:
23273       while (true) {
23274         switch (jj_nt.kind) {
23275         case FINAL:
23276         case INSTANTIABLE:
23277         case NOT:
23278         case OVERRIDING:
23279           ;
23280           break;
23281         default:
23282           jj_la1[323] = jj_gen;
23283           break label_73;
23284         }
23285         switch (jj_nt.kind) {
23286         case NOT:
23287           jj_consume_token(NOT);
23288           break;
23289         default:
23290           jj_la1[324] = jj_gen;
23291           ;
23292         }
23293         switch (jj_nt.kind) {
23294         case OVERRIDING:
23295           jj_consume_token(OVERRIDING);
23296           break;
23297         case INSTANTIABLE:
23298           jj_consume_token(INSTANTIABLE);
23299           break;
23300         case FINAL:
23301           jj_consume_token(FINAL);
23302           break;
23303         default:
23304           jj_la1[325] = jj_gen;
23305           jj_consume_token(-1);
23306           throw new ParseException();
23307         }
23308       }
23309       switch (jj_nt.kind) {
23310       case MAP:
23311       case ORDER:
23312         switch (jj_nt.kind) {
23313         case MAP:
23314           jj_consume_token(MAP);
23315           break;
23316         case ORDER:
23317           jj_consume_token(ORDER);
23318           break;
23319         default:
23320           jj_la1[326] = jj_gen;
23321           jj_consume_token(-1);
23322           throw new ParseException();
23323         }
23324         break;
23325       default:
23326         jj_la1[327] = jj_gen;
23327         ;
23328       }
23329       switch (jj_nt.kind) {
23330       case CONSTRUCTOR:
23331         jj_consume_token(CONSTRUCTOR);
23332         break;
23333       case MEMBER:
23334         jj_consume_token(MEMBER);
23335         break;
23336       case STATIC:
23337         jj_consume_token(STATIC);
23338         break;
23339       default:
23340         jj_la1[328] = jj_gen;
23341         jj_consume_token(-1);
23342         throw new ParseException();
23343       }
23344       MethodDeclarator();
23345       switch (jj_nt.kind) {
23346       case DETERMINISTIC:
23347         jj_consume_token(DETERMINISTIC);
23348         break;
23349       default:
23350         jj_la1[329] = jj_gen;
23351         ;
23352       }
23353       switch (jj_nt.kind) {
23354       case PARALLEL_ENABLE:
23355         jj_consume_token(PARALLEL_ENABLE);
23356         break;
23357       default:
23358         jj_la1[330] = jj_gen;
23359         ;
23360       }
23361       switch (jj_nt.kind) {
23362       case PIPELINED:
23363         jj_consume_token(PIPELINED);
23364         break;
23365       default:
23366         jj_la1[331] = jj_gen;
23367         ;
23368       }
23369       switch (jj_nt.kind) {
23370       case RESULT_CACHE:
23371         jj_consume_token(RESULT_CACHE);
23372         break;
23373       default:
23374         jj_la1[332] = jj_gen;
23375         ;
23376       }
23377       switch (jj_nt.kind) {
23378       case AS:
23379       case IS:
23380         switch (jj_nt.kind) {
23381         case IS:
23382           jj_consume_token(IS);
23383           break;
23384         case AS:
23385           jj_consume_token(AS);
23386           break;
23387         default:
23388           jj_la1[333] = jj_gen;
23389           jj_consume_token(-1);
23390           throw new ParseException();
23391         }
23392         switch (jj_nt.kind) {
23393         case LANGUAGE:
23394         case EXTERNAL:
23395           CallSpecTail();
23396           switch (jj_nt.kind) {
23397           case 4:
23398             jj_consume_token(4);
23399             break;
23400           default:
23401             jj_la1[334] = jj_gen;
23402             ;
23403           }
23404           break;
23405         case REPLACE:
23406         case DEFINER:
23407         case CURRENT_USER:
23408         case SERIALLY_REUSABLE:
23409         case RESTRICT_REFERENCES:
23410         case EXCEPTION_INIT:
23411         case AUTONOMOUS_TRANSACTION:
23412         case INLINE:
23413         case ADD:
23414         case AGGREGATE:
23415         case ALL:
23416         case ALTER:
23417         case AND:
23418         case ANY:
23419         case ARRAY:
23420         case AS:
23421         case ASC:
23422         case AT:
23423         case ATTRIBUTE:
23424         case AUTHID:
23425         case AVG:
23426         case BEGIN:
23427         case BETWEEN:
23428         case BINARY_INTEGER:
23429         case BODY:
23430         case BOOLEAN:
23431         case BULK:
23432         case BY:
23433         case BYTE:
23434         case CASCADE:
23435         case CASE:
23436         case CHAR:
23437         case CHAR_BASE:
23438         case CHECK:
23439         case CLOSE:
23440         case CLUSTER:
23441         case COALESCE:
23442         case COLLECT:
23443         case COLUMN:
23444         case COMMENT:
23445         case COMMIT:
23446         case COMPRESS:
23447         case CONNECT:
23448         case CONSTANT:
23449         case CONSTRUCTOR:
23450         case CONTINUE:
23451         case CONVERT:
23452         case CREATE:
23453         case CURRENT:
23454         case CURRVAL:
23455         case CURSOR:
23456         case DATA:
23457         case DATE:
23458         case DAY:
23459         case DECLARE:
23460         case DECIMAL:
23461         case _DEFAULT:
23462         case DELETE:
23463         case DESC:
23464         case DISABLE:
23465         case DISTINCT:
23466         case DO:
23467         case DROP:
23468         case EDITIONABLE:
23469         case ELEMENT:
23470         case ELSE:
23471         case ELSIF:
23472         case ENABLE:
23473         case ESCAPE:
23474         case EXCEPT:
23475         case EXCEPTION:
23476         case EXCEPTIONS:
23477         case EXCLUSIVE:
23478         case EXECUTE:
23479         case EXISTS:
23480         case EXIT:
23481         case EXTENDS:
23482         case EXTRACT:
23483         case FALSE:
23484         case FETCH:
23485         case FINAL:
23486         case FLOAT:
23487         case FOR:
23488         case FORALL:
23489         case FORCE:
23490         case FROM:
23491         case FUNCTION:
23492         case GLOBAL:
23493         case GOTO:
23494         case GROUP:
23495         case HASH:
23496         case HAVING:
23497         case HEAP:
23498         case HOUR:
23499         case IF:
23500         case IMMEDIATE:
23501         case IN:
23502         case INDEX:
23503         case INDICES:
23504         case INDEXTYPE:
23505         case INDICATOR:
23506         case INSERT:
23507         case INSTANTIABLE:
23508         case INTEGER:
23509         case INTERFACE:
23510         case INTERSECT:
23511         case INTERVAL:
23512         case INTO:
23513         case INVALIDATE:
23514         case IS:
23515         case ISOLATION:
23516         case JAVA:
23517         case LEVEL:
23518         case LIKE:
23519         case LIMIT:
23520         case LIMITED:
23521         case LOCK:
23522         case LONG:
23523         case LOOP:
23524         case MAP:
23525         case MAX:
23526         case MEMBER:
23527         case MERGE:
23528         case MIN:
23529         case MINUS:
23530         case MINUTE:
23531         case MLSLABEL:
23532         case MODIFY:
23533         case MOD:
23534         case MODE:
23535         case MONTH:
23536         case NATURAL:
23537         case NATURALN:
23538         case NEW:
23539         case NEXTVAL:
23540         case NO:
23541         case NOCOPY:
23542         case NONEDITIONABLE:
23543         case NOT:
23544         case NOWAIT:
23545         case NULL:
23546         case NULLIF:
23547         case NUMBER:
23548         case BFILE_BASE:
23549         case BLOB_BASE:
23550         case CLOB_BASE:
23551         case DATE_BASE:
23552         case NUMBER_BASE:
23553         case OBJECT:
23554         case OCIROWID:
23555         case OF:
23556         case OID:
23557         case ON:
23558         case OPAQUE:
23559         case OPEN:
23560         case OPERATOR:
23561         case OPTION:
23562         case OR:
23563         case ORDER:
23564         case ORGANIZATION:
23565         case OTHERS:
23566         case OUT:
23567         case OVERRIDING:
23568         case PACKAGE:
23569         case PARTITION:
23570         case PCTFREE:
23571         case PLS_INTEGER:
23572         case POSITIVE:
23573         case POSITIVEN:
23574         case PRAGMA:
23575         case PRESERVE:
23576         case PRIOR:
23577         case PROMPT:
23578         case PRIVATE:
23579         case PROCEDURE:
23580         case PUBLIC:
23581         case RAISE:
23582         case RANGE:
23583         case RAW:
23584         case REAL:
23585         case RECORD:
23586         case REF:
23587         case RELEASE:
23588         case RELIES_ON:
23589         case RENAME:
23590         case RESULT:
23591         case RETURN:
23592         case RETURNING:
23593         case REVERSE:
23594         case ROLLBACK:
23595         case ROW:
23596         case ROWS:
23597         case ROWID:
23598         case ROWNUM:
23599         case ROWTYPE:
23600         case SAVE:
23601         case SAVEPOINT:
23602         case SECOND:
23603         case SELECT:
23604         case SELF:
23605         case SEPARATE:
23606         case SET:
23607         case SHARE:
23608         case SMALLINT:
23609         case SPACE:
23610         case SQL:
23611         case SQLCODE:
23612         case SQLERRM:
23613         case START:
23614         case STATIC:
23615         case STDDEV:
23616         case SUBTYPE:
23617         case SUBSTITUTABLE:
23618         case SUCCESSFUL:
23619         case SUM:
23620         case SYNONYM:
23621         case SYSDATE:
23622         case SYS_REFCURSOR:
23623         case TABLE:
23624         case TEMPORARY:
23625         case THEN:
23626         case TIME:
23627         case TIMESTAMP:
23628         case TIMEZONE_REGION:
23629         case TIMEZONE_ABBR:
23630         case TIMEZONE_MINUTE:
23631         case TIMEZONE_HOUR:
23632         case TO:
23633         case TRANSACTION:
23634         case TRIGGER:
23635         case TRUE:
23636         case TYPE:
23637         case UI:
23638         case UNDER:
23639         case USING:
23640         case WHILE:
23641         case YES:
23642         case SHOW:
23643         case A:
23644         case UPDATE:
23645         case VARCHAR:
23646         case VARCHAR2:
23647         case DOUBLE:
23648         case DEC:
23649         case PRECISION:
23650         case INT:
23651         case NUMERIC:
23652         case SIGNTYPE:
23653         case NCHAR:
23654         case NVARCHAR2:
23655         case STRING:
23656         case UROWID:
23657         case VARRAY:
23658         case VARYING:
23659         case BFILE:
23660         case BLOB:
23661         case CLOB:
23662         case NCLOB:
23663         case YEAR:
23664         case LOCAL:
23665         case WITH:
23666         case ZONE:
23667         case CHARACTER:
23668         case AFTER:
23669         case BEFORE:
23670         case OLD:
23671         case PARENT:
23672         case CC_IF:
23673         case ANALYZE:
23674         case ASSOCIATE:
23675         case AUDIT:
23676         case COMPOUND:
23677         case DATABASE:
23678         case CALL:
23679         case DDL:
23680         case DISASSOCIATE:
23681         case EACH:
23682         case FOLLOWS:
23683         case LOGOFF:
23684         case LOGON:
23685         case NESTED:
23686         case NOAUDIT:
23687         case SCHEMA:
23688         case SERVERERROR:
23689         case SHUTDOWN:
23690         case STARTUP:
23691         case STATEMENT:
23692         case STATISTICS:
23693         case SUSPEND:
23694         case TRUNCATE:
23695         case WRAPPED:
23696         case LIBRARY:
23697         case NAME:
23698         case STRUCT:
23699         case CONTEXT:
23700         case PARAMETERS:
23701         case LENGTH:
23702         case TDO:
23703         case MAXLEN:
23704         case CHARSETID:
23705         case CHARSETFORM:
23706         case ACCEPT:
23707         case ACCESSIBLE:
23708         case COPY:
23709         case DEFINE:
23710         case DISCONNECT:
23711         case HOST:
23712         case PRINT:
23713         case QUIT:
23714         case REMARK:
23715         case UNDEFINE:
23716         case VARIABLE:
23717         case WHENEVER:
23718         case ATTACH:
23719         case CAST:
23720         case TREAT:
23721         case TRIM:
23722         case LEFT:
23723         case RIGHT:
23724         case BOTH:
23725         case EMPTY:
23726         case MULTISET:
23727         case SUBMULTISET:
23728         case LEADING:
23729         case TRAILING:
23730         case CHAR_CS:
23731         case NCHAR_CS:
23732         case DBTIMEZONE:
23733         case SESSIONTIMEZONE:
23734         case AUTHENTICATED:
23735         case LINK:
23736         case SHARED:
23737         case DIRECTORY:
23738         case USER:
23739         case IDENTIFIER:
23740         case QUOTED_LITERAL:
23741         case SQLDATA_CLASS:
23742         case CUSTOMDATUM_CLASS:
23743         case ORADATA_CLASS:
23744         case JAVA_INTERFACE_CLASS:
23745           DeclarativeSection();
23746           jj_consume_token(BEGIN);
23747           label_74:
23748           while (true) {
23749             switch (jj_nt.kind) {
23750             case 5:
23751             case 16:
23752             case 17:
23753             case 21:
23754             case REPLACE:
23755             case DEFINER:
23756             case CURRENT_USER:
23757             case LANGUAGE:
23758             case INLINE:
23759             case ADD:
23760             case AGGREGATE:
23761             case ARRAY:
23762             case AT:
23763             case ATTRIBUTE:
23764             case AUTHID:
23765             case BEGIN:
23766             case BODY:
23767             case BULK:
23768             case BYTE:
23769             case CASCADE:
23770             case CASE:
23771             case CLOSE:
23772             case COALESCE:
23773             case COLLECT:
23774             case COLUMN:
23775             case COMMENT:
23776             case COMMIT:
23777             case CONSTRUCTOR:
23778             case CONTINUE:
23779             case CONVERT:
23780             case CURRENT:
23781             case CURSOR:
23782             case DATA:
23783             case DATE:
23784             case DAY:
23785             case DECLARE:
23786             case DELETE:
23787             case DISABLE:
23788             case EDITIONABLE:
23789             case ELEMENT:
23790             case ENABLE:
23791             case ESCAPE:
23792             case EXCEPT:
23793             case EXCEPTIONS:
23794             case EXECUTE:
23795             case EXIT:
23796             case EXTERNAL:
23797             case EXTENDS:
23798             case EXTRACT:
23799             case FALSE:
23800             case FETCH:
23801             case FINAL:
23802             case FOR:
23803             case FORALL:
23804             case FORCE:
23805             case FUNCTION:
23806             case GLOBAL:
23807             case GOTO:
23808             case HASH:
23809             case HEAP:
23810             case HOUR:
23811             case IF:
23812             case IMMEDIATE:
23813             case INDICES:
23814             case INDEXTYPE:
23815             case INDICATOR:
23816             case INSERT:
23817             case INSTANTIABLE:
23818             case INTERVAL:
23819             case INVALIDATE:
23820             case ISOLATION:
23821             case JAVA:
23822             case LEVEL:
23823             case LIMIT:
23824             case LOCK:
23825             case LOOP:
23826             case MAP:
23827             case MAX:
23828             case MEMBER:
23829             case MERGE:
23830             case MIN:
23831             case MINUTE:
23832             case MLSLABEL:
23833             case MODIFY:
23834             case MOD:
23835             case MONTH:
23836             case NATURAL:
23837             case NEW:
23838             case NEW_DOT:
23839             case NO:
23840             case NONEDITIONABLE:
23841             case NOT:
23842             case NULL:
23843             case NULLIF:
23844             case OBJECT:
23845             case OID:
23846             case OPAQUE:
23847             case OPEN:
23848             case OPERATOR:
23849             case ORGANIZATION:
23850             case OTHERS:
23851             case OVERRIDING:
23852             case PACKAGE:
23853             case PARTITION:
23854             case PIPE:
23855             case PRAGMA:
23856             case PRESERVE:
23857             case PRIVATE:
23858             case PROCEDURE:
23859             case RAISE:
23860             case RANGE:
23861             case RAW:
23862             case REAL:
23863             case RECORD:
23864             case REF:
23865             case RELEASE:
23866             case RELIES_ON:
23867             case RENAME:
23868             case RESULT:
23869             case RETURN:
23870             case RETURNING:
23871             case REVERSE:
23872             case ROLLBACK:
23873             case ROW:
23874             case ROWS:
23875             case ROWID:
23876             case ROWNUM:
23877             case SAVE:
23878             case SAVEPOINT:
23879             case SECOND:
23880             case SELECT:
23881             case SELF:
23882             case SET:
23883             case SPACE:
23884             case SQL:
23885             case SQLCODE:
23886             case SQLERRM:
23887             case STATIC:
23888             case SUBTYPE:
23889             case SUBSTITUTABLE:
23890             case SUCCESSFUL:
23891             case SYSDATE:
23892             case SYS_REFCURSOR:
23893             case TEMPORARY:
23894             case TIME:
23895             case TIMESTAMP:
23896             case TIMEZONE_REGION:
23897             case TIMEZONE_ABBR:
23898             case TIMEZONE_MINUTE:
23899             case TIMEZONE_HOUR:
23900             case TRANSACTION:
23901             case TRUE:
23902             case TYPE:
23903             case UNDER:
23904             case USING:
23905             case WHILE:
23906             case YES:
23907             case SHOW:
23908             case A:
23909             case UPDATE:
23910             case DOUBLE:
23911             case DEC:
23912             case PRECISION:
23913             case INT:
23914             case NUMERIC:
23915             case NCHAR:
23916             case NVARCHAR2:
23917             case STRING:
23918             case UROWID:
23919             case VARRAY:
23920             case VARYING:
23921             case BFILE:
23922             case BLOB:
23923             case CLOB:
23924             case NCLOB:
23925             case YEAR:
23926             case LOCAL:
23927             case WITH:
23928             case ZONE:
23929             case CHARACTER:
23930             case AFTER:
23931             case BEFORE:
23932             case OLD:
23933             case PARENT:
23934             case CC_IF:
23935             case CC_ERROR:
23936             case ANALYZE:
23937             case ASSOCIATE:
23938             case AUDIT:
23939             case COMPOUND:
23940             case DATABASE:
23941             case CALL:
23942             case DDL:
23943             case DISASSOCIATE:
23944             case EACH:
23945             case FOLLOWS:
23946             case LOGOFF:
23947             case LOGON:
23948             case NESTED:
23949             case NOAUDIT:
23950             case SCHEMA:
23951             case SERVERERROR:
23952             case SHUTDOWN:
23953             case STARTUP:
23954             case STATEMENT:
23955             case STATISTICS:
23956             case SUSPEND:
23957             case TRUNCATE:
23958             case WRAPPED:
23959             case LIBRARY:
23960             case NAME:
23961             case STRUCT:
23962             case CONTEXT:
23963             case PARAMETERS:
23964             case LENGTH:
23965             case TDO:
23966             case MAXLEN:
23967             case CHARSETID:
23968             case CHARSETFORM:
23969             case ACCEPT:
23970             case ACCESSIBLE:
23971             case COPY:
23972             case DEFINE:
23973             case DISCONNECT:
23974             case HOST:
23975             case PRINT:
23976             case QUIT:
23977             case REMARK:
23978             case UNDEFINE:
23979             case VARIABLE:
23980             case WHENEVER:
23981             case ATTACH:
23982             case CAST:
23983             case TREAT:
23984             case TRIM:
23985             case LEFT:
23986             case RIGHT:
23987             case BOTH:
23988             case EMPTY:
23989             case MULTISET:
23990             case SUBMULTISET:
23991             case LEADING:
23992             case TRAILING:
23993             case CHAR_CS:
23994             case NCHAR_CS:
23995             case DBTIMEZONE:
23996             case SESSIONTIMEZONE:
23997             case AUTHENTICATED:
23998             case LINK:
23999             case SHARED:
24000             case DIRECTORY:
24001             case USER:
24002             case IDENTIFIER:
24003             case UNSIGNED_NUMERIC_LITERAL:
24004             case CHARACTER_LITERAL:
24005             case STRING_LITERAL:
24006             case QUOTED_LITERAL:
24007               ;
24008               break;
24009             default:
24010               jj_la1[335] = jj_gen;
24011               break label_74;
24012             }
24013             Statement();
24014           }
24015           switch (jj_nt.kind) {
24016           case EXCEPTION:
24017             ExceptionHandler();
24018             break;
24019           default:
24020             jj_la1[336] = jj_gen;
24021             ;
24022           }
24023           jj_consume_token(END);
24024           switch (jj_nt.kind) {
24025           case REPLACE:
24026           case DEFINER:
24027           case CURRENT_USER:
24028           case SERIALLY_REUSABLE:
24029           case RESTRICT_REFERENCES:
24030           case EXCEPTION_INIT:
24031           case AUTONOMOUS_TRANSACTION:
24032           case LANGUAGE:
24033           case INLINE:
24034           case ADD:
24035           case AGGREGATE:
24036           case ALL:
24037           case ALTER:
24038           case AND:
24039           case ANY:
24040           case ARRAY:
24041           case AS:
24042           case ASC:
24043           case AT:
24044           case ATTRIBUTE:
24045           case AUTHID:
24046           case AVG:
24047           case BETWEEN:
24048           case BINARY_INTEGER:
24049           case BODY:
24050           case BOOLEAN:
24051           case BULK:
24052           case BY:
24053           case BYTE:
24054           case CASCADE:
24055           case CASE:
24056           case CHAR:
24057           case CHAR_BASE:
24058           case CHECK:
24059           case CLOSE:
24060           case CLUSTER:
24061           case COALESCE:
24062           case COLLECT:
24063           case COLUMN:
24064           case COMMENT:
24065           case COMMIT:
24066           case COMPRESS:
24067           case CONNECT:
24068           case CONSTANT:
24069           case CONSTRUCTOR:
24070           case CONTINUE:
24071           case CONVERT:
24072           case CREATE:
24073           case CURRENT:
24074           case CURRVAL:
24075           case CURSOR:
24076           case DATA:
24077           case DATE:
24078           case DAY:
24079           case DECLARE:
24080           case DECIMAL:
24081           case _DEFAULT:
24082           case DELETE:
24083           case DESC:
24084           case DISABLE:
24085           case DISTINCT:
24086           case DO:
24087           case DROP:
24088           case EDITIONABLE:
24089           case ELEMENT:
24090           case ELSE:
24091           case ELSIF:
24092           case ENABLE:
24093           case ESCAPE:
24094           case EXCEPT:
24095           case EXCEPTION:
24096           case EXCEPTIONS:
24097           case EXCLUSIVE:
24098           case EXECUTE:
24099           case EXISTS:
24100           case EXIT:
24101           case EXTERNAL:
24102           case EXTENDS:
24103           case EXTRACT:
24104           case FALSE:
24105           case FETCH:
24106           case FINAL:
24107           case FLOAT:
24108           case FOR:
24109           case FORALL:
24110           case FORCE:
24111           case FROM:
24112           case FUNCTION:
24113           case GLOBAL:
24114           case GOTO:
24115           case GROUP:
24116           case HASH:
24117           case HAVING:
24118           case HEAP:
24119           case HOUR:
24120           case IF:
24121           case IMMEDIATE:
24122           case IN:
24123           case INDEX:
24124           case INDICES:
24125           case INDEXTYPE:
24126           case INDICATOR:
24127           case INSERT:
24128           case INSTANTIABLE:
24129           case INTEGER:
24130           case INTERFACE:
24131           case INTERSECT:
24132           case INTERVAL:
24133           case INTO:
24134           case INVALIDATE:
24135           case IS:
24136           case ISOLATION:
24137           case JAVA:
24138           case LEVEL:
24139           case LIKE:
24140           case LIMIT:
24141           case LIMITED:
24142           case LOCK:
24143           case LONG:
24144           case LOOP:
24145           case MAP:
24146           case MAX:
24147           case MEMBER:
24148           case MERGE:
24149           case MIN:
24150           case MINUS:
24151           case MINUTE:
24152           case MLSLABEL:
24153           case MODIFY:
24154           case MOD:
24155           case MODE:
24156           case MONTH:
24157           case NATURAL:
24158           case NATURALN:
24159           case NEW:
24160           case NEXTVAL:
24161           case NO:
24162           case NOCOPY:
24163           case NONEDITIONABLE:
24164           case NOT:
24165           case NOWAIT:
24166           case NULL:
24167           case NULLIF:
24168           case NUMBER:
24169           case BFILE_BASE:
24170           case BLOB_BASE:
24171           case CLOB_BASE:
24172           case DATE_BASE:
24173           case NUMBER_BASE:
24174           case OBJECT:
24175           case OCIROWID:
24176           case OF:
24177           case OID:
24178           case ON:
24179           case OPAQUE:
24180           case OPEN:
24181           case OPERATOR:
24182           case OPTION:
24183           case OR:
24184           case ORDER:
24185           case ORGANIZATION:
24186           case OTHERS:
24187           case OUT:
24188           case OVERRIDING:
24189           case PACKAGE:
24190           case PARTITION:
24191           case PCTFREE:
24192           case PLS_INTEGER:
24193           case POSITIVE:
24194           case POSITIVEN:
24195           case PRESERVE:
24196           case PRIOR:
24197           case PROMPT:
24198           case PRIVATE:
24199           case PROCEDURE:
24200           case PUBLIC:
24201           case RAISE:
24202           case RANGE:
24203           case RAW:
24204           case REAL:
24205           case RECORD:
24206           case REF:
24207           case RELEASE:
24208           case RELIES_ON:
24209           case RENAME:
24210           case RESULT:
24211           case RETURN:
24212           case RETURNING:
24213           case REVERSE:
24214           case ROLLBACK:
24215           case ROW:
24216           case ROWS:
24217           case ROWID:
24218           case ROWNUM:
24219           case ROWTYPE:
24220           case SAVE:
24221           case SAVEPOINT:
24222           case SECOND:
24223           case SELECT:
24224           case SELF:
24225           case SEPARATE:
24226           case SET:
24227           case SHARE:
24228           case SMALLINT:
24229           case SPACE:
24230           case SQL:
24231           case SQLCODE:
24232           case SQLERRM:
24233           case START:
24234           case STATIC:
24235           case STDDEV:
24236           case SUBTYPE:
24237           case SUBSTITUTABLE:
24238           case SUCCESSFUL:
24239           case SUM:
24240           case SYNONYM:
24241           case SYSDATE:
24242           case SYS_REFCURSOR:
24243           case TABLE:
24244           case TEMPORARY:
24245           case THEN:
24246           case TIME:
24247           case TIMESTAMP:
24248           case TIMEZONE_REGION:
24249           case TIMEZONE_ABBR:
24250           case TIMEZONE_MINUTE:
24251           case TIMEZONE_HOUR:
24252           case TO:
24253           case TRANSACTION:
24254           case TRIGGER:
24255           case TRUE:
24256           case TYPE:
24257           case UI:
24258           case UNDER:
24259           case USING:
24260           case WHILE:
24261           case YES:
24262           case SHOW:
24263           case A:
24264           case UPDATE:
24265           case VARCHAR:
24266           case VARCHAR2:
24267           case DOUBLE:
24268           case DEC:
24269           case PRECISION:
24270           case INT:
24271           case NUMERIC:
24272           case SIGNTYPE:
24273           case NCHAR:
24274           case NVARCHAR2:
24275           case STRING:
24276           case UROWID:
24277           case VARRAY:
24278           case VARYING:
24279           case BFILE:
24280           case BLOB:
24281           case CLOB:
24282           case NCLOB:
24283           case YEAR:
24284           case LOCAL:
24285           case WITH:
24286           case ZONE:
24287           case CHARACTER:
24288           case AFTER:
24289           case BEFORE:
24290           case OLD:
24291           case PARENT:
24292           case ANALYZE:
24293           case ASSOCIATE:
24294           case AUDIT:
24295           case COMPOUND:
24296           case DATABASE:
24297           case CALL:
24298           case DDL:
24299           case DISASSOCIATE:
24300           case EACH:
24301           case FOLLOWS:
24302           case LOGOFF:
24303           case LOGON:
24304           case NESTED:
24305           case NOAUDIT:
24306           case SCHEMA:
24307           case SERVERERROR:
24308           case SHUTDOWN:
24309           case STARTUP:
24310           case STATEMENT:
24311           case STATISTICS:
24312           case SUSPEND:
24313           case TRUNCATE:
24314           case WRAPPED:
24315           case LIBRARY:
24316           case NAME:
24317           case STRUCT:
24318           case CONTEXT:
24319           case PARAMETERS:
24320           case LENGTH:
24321           case TDO:
24322           case MAXLEN:
24323           case CHARSETID:
24324           case CHARSETFORM:
24325           case ACCEPT:
24326           case ACCESSIBLE:
24327           case COPY:
24328           case DEFINE:
24329           case DISCONNECT:
24330           case HOST:
24331           case PRINT:
24332           case QUIT:
24333           case REMARK:
24334           case UNDEFINE:
24335           case VARIABLE:
24336           case WHENEVER:
24337           case ATTACH:
24338           case CAST:
24339           case TREAT:
24340           case TRIM:
24341           case LEFT:
24342           case RIGHT:
24343           case BOTH:
24344           case EMPTY:
24345           case MULTISET:
24346           case SUBMULTISET:
24347           case LEADING:
24348           case TRAILING:
24349           case CHAR_CS:
24350           case NCHAR_CS:
24351           case DBTIMEZONE:
24352           case SESSIONTIMEZONE:
24353           case AUTHENTICATED:
24354           case LINK:
24355           case SHARED:
24356           case DIRECTORY:
24357           case USER:
24358           case IDENTIFIER:
24359           case QUOTED_LITERAL:
24360           case SQLDATA_CLASS:
24361           case CUSTOMDATUM_CLASS:
24362           case ORADATA_CLASS:
24363           case JAVA_INTERFACE_CLASS:
24364             ID();
24365             break;
24366           default:
24367             jj_la1[337] = jj_gen;
24368             ;
24369           }
24370           jj_consume_token(4);
24371           break;
24372         default:
24373           jj_la1[338] = jj_gen;
24374           jj_consume_token(-1);
24375           throw new ParseException();
24376         }
24377         break;
24378       default:
24379         jj_la1[339] = jj_gen;
24380         ;
24381       }
24382         jjtree.closeNodeScope(jjtn000, true);
24383         jjtc000 = false;
24384         {if (true) return jjtn000 ;}
24385     } catch (Throwable jjte000) {
24386           if (jjtc000) {
24387             jjtree.clearNodeScope(jjtn000);
24388             jjtc000 = false;
24389           } else {
24390             jjtree.popNode();
24391           }
24392           if (jjte000 instanceof RuntimeException) {
24393             {if (true) throw (RuntimeException)jjte000;}
24394           }
24395           if (jjte000 instanceof ParseException) {
24396             {if (true) throw (ParseException)jjte000;}
24397           }
24398           {if (true) throw (Error)jjte000;}
24399     } finally {
24400           if (jjtc000) {
24401             jjtree.closeNodeScope(jjtn000, true);
24402           }
24403     }
24404     throw new Error("Missing return statement in function");
24405   }
24406 
24407   final public ASTTypeSpecification TypeSpecification() throws ParseException {
24408  /*@bgen(jjtree) TypeSpecification */
24409  ASTTypeSpecification jjtn000 = new ASTTypeSpecification(this, JJTTYPESPECIFICATION);
24410  boolean jjtc000 = true;
24411  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
24412     try {
24413       switch (jj_nt.kind) {
24414       case CREATE:
24415         jj_consume_token(CREATE);
24416         switch (jj_nt.kind) {
24417         case OR:
24418           jj_consume_token(OR);
24419           jj_consume_token(REPLACE);
24420           break;
24421         default:
24422           jj_la1[340] = jj_gen;
24423           ;
24424         }
24425         switch (jj_nt.kind) {
24426         case EDITIONABLE:
24427         case NONEDITIONABLE:
24428           switch (jj_nt.kind) {
24429           case EDITIONABLE:
24430             jj_consume_token(EDITIONABLE);
24431             break;
24432           case NONEDITIONABLE:
24433             jj_consume_token(NONEDITIONABLE);
24434             break;
24435           default:
24436             jj_la1[341] = jj_gen;
24437             jj_consume_token(-1);
24438             throw new ParseException();
24439           }
24440           break;
24441         default:
24442           jj_la1[342] = jj_gen;
24443           ;
24444         }
24445         break;
24446       default:
24447         jj_la1[343] = jj_gen;
24448         ;
24449       }
24450       jj_consume_token(TYPE);
24451       simpleNode = ObjectNameDeclaration();
24452       switch (jj_nt.kind) {
24453       case FORCE:
24454         jj_consume_token(FORCE);
24455         break;
24456       default:
24457         jj_la1[344] = jj_gen;
24458         ;
24459       }
24460       if (jj_2_62(2)) {
24461         jj_consume_token(OID);
24462         jj_consume_token(STRING_LITERAL);
24463       } else {
24464         ;
24465       }
24466       label_75:
24467       while (true) {
24468         if (jj_2_63(2)) {
24469           ;
24470         } else {
24471           break label_75;
24472         }
24473         switch (jj_nt.kind) {
24474         case AUTHID:
24475           jj_consume_token(AUTHID);
24476           switch (jj_nt.kind) {
24477           case CURRENT_USER:
24478             jj_consume_token(CURRENT_USER);
24479             break;
24480           case DEFINER:
24481             jj_consume_token(DEFINER);
24482             break;
24483           default:
24484             jj_la1[345] = jj_gen;
24485             jj_consume_token(-1);
24486             throw new ParseException();
24487           }
24488           break;
24489         case ACCESSIBLE:
24490           AccessibleByClause();
24491           break;
24492         default:
24493           jj_la1[346] = jj_gen;
24494           jj_consume_token(-1);
24495           throw new ParseException();
24496         }
24497       }
24498       switch (jj_nt.kind) {
24499       case AS:
24500       case IS:
24501       case UNDER:
24502         switch (jj_nt.kind) {
24503         case UNDER:
24504           jj_consume_token(UNDER);
24505           ObjectNameDeclaration();
24506           break;
24507         default:
24508           jj_la1[353] = jj_gen;
24509           if (jj_2_64(2)) {
24510             switch (jj_nt.kind) {
24511             case IS:
24512               jj_consume_token(IS);
24513               break;
24514             case AS:
24515               jj_consume_token(AS);
24516               break;
24517             default:
24518               jj_la1[347] = jj_gen;
24519               jj_consume_token(-1);
24520               throw new ParseException();
24521             }
24522             jj_consume_token(OBJECT);
24523           } else if (jj_2_65(2)) {
24524             switch (jj_nt.kind) {
24525             case IS:
24526               jj_consume_token(IS);
24527               break;
24528             case AS:
24529               jj_consume_token(AS);
24530               break;
24531             default:
24532               jj_la1[348] = jj_gen;
24533               jj_consume_token(-1);
24534               throw new ParseException();
24535             }
24536             jj_consume_token(OPAQUE);
24537             jj_consume_token(VARYING);
24538             jj_consume_token(24);
24539             jj_consume_token(USING);
24540             jj_consume_token(LIBRARY);
24541             switch (jj_nt.kind) {
24542             case IDENTIFIER:
24543               jj_consume_token(IDENTIFIER);
24544               break;
24545             case QUOTED_LITERAL:
24546               jj_consume_token(QUOTED_LITERAL);
24547               break;
24548             case STRING_LITERAL:
24549               StringLiteral();
24550               break;
24551             default:
24552               jj_la1[349] = jj_gen;
24553               jj_consume_token(-1);
24554               throw new ParseException();
24555             }
24556             switch (jj_nt.kind) {
24557             case 3:
24558               jj_consume_token(3);
24559               switch (jj_nt.kind) {
24560               case IDENTIFIER:
24561                 jj_consume_token(IDENTIFIER);
24562                 break;
24563               case QUOTED_LITERAL:
24564                 jj_consume_token(QUOTED_LITERAL);
24565                 break;
24566               case STRING_LITERAL:
24567                 StringLiteral();
24568                 break;
24569               default:
24570                 jj_la1[350] = jj_gen;
24571                 jj_consume_token(-1);
24572                 throw new ParseException();
24573               }
24574               break;
24575             default:
24576               jj_la1[351] = jj_gen;
24577               ;
24578             }
24579           } else if (jj_2_66(2)) {
24580             switch (jj_nt.kind) {
24581             case IS:
24582               jj_consume_token(IS);
24583               break;
24584             case AS:
24585               jj_consume_token(AS);
24586               break;
24587             default:
24588               jj_la1[352] = jj_gen;
24589               jj_consume_token(-1);
24590               throw new ParseException();
24591             }
24592             CollectionTypeName();
24593             jj_consume_token(OF);
24594             Datatype();
24595           } else {
24596             jj_consume_token(-1);
24597             throw new ParseException();
24598           }
24599         }
24600         break;
24601       default:
24602         jj_la1[354] = jj_gen;
24603         ;
24604       }
24605       if (jj_2_67(8)) {
24606         jj_consume_token(EXTERNAL);
24607         jj_consume_token(IDENTIFIER);
24608         jj_consume_token(IDENTIFIER);
24609         jj_consume_token(LANGUAGE);
24610         jj_consume_token(JAVA);
24611         jj_consume_token(USING);
24612         jj_consume_token(IDENTIFIER);
24613       } else {
24614         ;
24615       }
24616       switch (jj_nt.kind) {
24617       case WRAPPED:
24618         WrappedObject();
24619         break;
24620       default:
24621         jj_la1[355] = jj_gen;
24622         ;
24623       }
24624       switch (jj_nt.kind) {
24625       case 5:
24626         jj_consume_token(5);
24627         label_76:
24628         while (true) {
24629           switch (jj_nt.kind) {
24630           case REPLACE:
24631           case DEFINER:
24632           case CURRENT_USER:
24633           case SERIALLY_REUSABLE:
24634           case RESTRICT_REFERENCES:
24635           case EXCEPTION_INIT:
24636           case AUTONOMOUS_TRANSACTION:
24637           case LANGUAGE:
24638           case INLINE:
24639           case ADD:
24640           case AGGREGATE:
24641           case ALL:
24642           case ALTER:
24643           case AND:
24644           case ANY:
24645           case ARRAY:
24646           case AS:
24647           case ASC:
24648           case AT:
24649           case ATTRIBUTE:
24650           case AUTHID:
24651           case AVG:
24652           case BETWEEN:
24653           case BINARY_INTEGER:
24654           case BODY:
24655           case BOOLEAN:
24656           case BULK:
24657           case BY:
24658           case BYTE:
24659           case CASCADE:
24660           case CASE:
24661           case CHAR:
24662           case CHAR_BASE:
24663           case CHECK:
24664           case CLOSE:
24665           case CLUSTER:
24666           case COALESCE:
24667           case COLLECT:
24668           case COLUMN:
24669           case COMMENT:
24670           case COMMIT:
24671           case COMPRESS:
24672           case CONNECT:
24673           case CONSTANT:
24674           case CONSTRUCTOR:
24675           case CONTINUE:
24676           case CONVERT:
24677           case CREATE:
24678           case CURRENT:
24679           case CURRVAL:
24680           case CURSOR:
24681           case DATA:
24682           case DATE:
24683           case DAY:
24684           case DECLARE:
24685           case DECIMAL:
24686           case _DEFAULT:
24687           case DELETE:
24688           case DESC:
24689           case DISABLE:
24690           case DISTINCT:
24691           case DO:
24692           case DROP:
24693           case EDITIONABLE:
24694           case ELEMENT:
24695           case ELSE:
24696           case ELSIF:
24697           case ENABLE:
24698           case ESCAPE:
24699           case EXCEPT:
24700           case EXCEPTION:
24701           case EXCEPTIONS:
24702           case EXCLUSIVE:
24703           case EXECUTE:
24704           case EXISTS:
24705           case EXIT:
24706           case EXTERNAL:
24707           case EXTENDS:
24708           case EXTRACT:
24709           case FALSE:
24710           case FETCH:
24711           case FINAL:
24712           case FLOAT:
24713           case FOR:
24714           case FORALL:
24715           case FORCE:
24716           case FROM:
24717           case FUNCTION:
24718           case GLOBAL:
24719           case GOTO:
24720           case GROUP:
24721           case HASH:
24722           case HAVING:
24723           case HEAP:
24724           case HOUR:
24725           case IF:
24726           case IMMEDIATE:
24727           case IN:
24728           case INDEX:
24729           case INDICES:
24730           case INDEXTYPE:
24731           case INDICATOR:
24732           case INSERT:
24733           case INSTANTIABLE:
24734           case INTEGER:
24735           case INTERFACE:
24736           case INTERSECT:
24737           case INTERVAL:
24738           case INTO:
24739           case INVALIDATE:
24740           case IS:
24741           case ISOLATION:
24742           case JAVA:
24743           case LEVEL:
24744           case LIKE:
24745           case LIMIT:
24746           case LIMITED:
24747           case LOCK:
24748           case LONG:
24749           case LOOP:
24750           case MAP:
24751           case MAX:
24752           case MEMBER:
24753           case MERGE:
24754           case MIN:
24755           case MINUS:
24756           case MINUTE:
24757           case MLSLABEL:
24758           case MODIFY:
24759           case MOD:
24760           case MODE:
24761           case MONTH:
24762           case NATURAL:
24763           case NATURALN:
24764           case NEW:
24765           case NEXTVAL:
24766           case NO:
24767           case NOCOPY:
24768           case NONEDITIONABLE:
24769           case NOT:
24770           case NOWAIT:
24771           case NULL:
24772           case NULLIF:
24773           case NUMBER:
24774           case BFILE_BASE:
24775           case BLOB_BASE:
24776           case CLOB_BASE:
24777           case DATE_BASE:
24778           case NUMBER_BASE:
24779           case OBJECT:
24780           case OCIROWID:
24781           case OF:
24782           case OID:
24783           case ON:
24784           case OPAQUE:
24785           case OPEN:
24786           case OPERATOR:
24787           case OPTION:
24788           case OR:
24789           case ORDER:
24790           case ORGANIZATION:
24791           case OTHERS:
24792           case OUT:
24793           case OVERRIDING:
24794           case PACKAGE:
24795           case PARTITION:
24796           case PCTFREE:
24797           case PLS_INTEGER:
24798           case POSITIVE:
24799           case POSITIVEN:
24800           case PRAGMA:
24801           case PRESERVE:
24802           case PRIOR:
24803           case PROMPT:
24804           case PRIVATE:
24805           case PROCEDURE:
24806           case PUBLIC:
24807           case RAISE:
24808           case RANGE:
24809           case RAW:
24810           case REAL:
24811           case RECORD:
24812           case REF:
24813           case RELEASE:
24814           case RELIES_ON:
24815           case RENAME:
24816           case RESULT:
24817           case RETURN:
24818           case RETURNING:
24819           case REVERSE:
24820           case ROLLBACK:
24821           case ROW:
24822           case ROWS:
24823           case ROWID:
24824           case ROWNUM:
24825           case ROWTYPE:
24826           case SAVE:
24827           case SAVEPOINT:
24828           case SECOND:
24829           case SELECT:
24830           case SELF:
24831           case SEPARATE:
24832           case SET:
24833           case SHARE:
24834           case SMALLINT:
24835           case SPACE:
24836           case SQL:
24837           case SQLCODE:
24838           case SQLERRM:
24839           case START:
24840           case STATIC:
24841           case STDDEV:
24842           case SUBTYPE:
24843           case SUBSTITUTABLE:
24844           case SUCCESSFUL:
24845           case SUM:
24846           case SYNONYM:
24847           case SYSDATE:
24848           case SYS_REFCURSOR:
24849           case TABLE:
24850           case TEMPORARY:
24851           case THEN:
24852           case TIME:
24853           case TIMESTAMP:
24854           case TIMEZONE_REGION:
24855           case TIMEZONE_ABBR:
24856           case TIMEZONE_MINUTE:
24857           case TIMEZONE_HOUR:
24858           case TO:
24859           case TRANSACTION:
24860           case TRIGGER:
24861           case TRUE:
24862           case TYPE:
24863           case UI:
24864           case UNDER:
24865           case USING:
24866           case WHILE:
24867           case YES:
24868           case SHOW:
24869           case A:
24870           case UPDATE:
24871           case VARCHAR:
24872           case VARCHAR2:
24873           case DOUBLE:
24874           case DEC:
24875           case PRECISION:
24876           case INT:
24877           case NUMERIC:
24878           case SIGNTYPE:
24879           case NCHAR:
24880           case NVARCHAR2:
24881           case STRING:
24882           case UROWID:
24883           case VARRAY:
24884           case VARYING:
24885           case BFILE:
24886           case BLOB:
24887           case CLOB:
24888           case NCLOB:
24889           case YEAR:
24890           case LOCAL:
24891           case WITH:
24892           case ZONE:
24893           case CHARACTER:
24894           case AFTER:
24895           case BEFORE:
24896           case OLD:
24897           case PARENT:
24898           case ANALYZE:
24899           case ASSOCIATE:
24900           case AUDIT:
24901           case COMPOUND:
24902           case DATABASE:
24903           case CALL:
24904           case DDL:
24905           case DISASSOCIATE:
24906           case EACH:
24907           case FOLLOWS:
24908           case LOGOFF:
24909           case LOGON:
24910           case NESTED:
24911           case NOAUDIT:
24912           case SCHEMA:
24913           case SERVERERROR:
24914           case SHUTDOWN:
24915           case STARTUP:
24916           case STATEMENT:
24917           case STATISTICS:
24918           case SUSPEND:
24919           case TRUNCATE:
24920           case WRAPPED:
24921           case LIBRARY:
24922           case NAME:
24923           case STRUCT:
24924           case CONTEXT:
24925           case PARAMETERS:
24926           case LENGTH:
24927           case TDO:
24928           case MAXLEN:
24929           case CHARSETID:
24930           case CHARSETFORM:
24931           case ACCEPT:
24932           case ACCESSIBLE:
24933           case COPY:
24934           case DEFINE:
24935           case DISCONNECT:
24936           case HOST:
24937           case PRINT:
24938           case QUIT:
24939           case REMARK:
24940           case UNDEFINE:
24941           case VARIABLE:
24942           case WHENEVER:
24943           case ATTACH:
24944           case CAST:
24945           case TREAT:
24946           case TRIM:
24947           case LEFT:
24948           case RIGHT:
24949           case BOTH:
24950           case EMPTY:
24951           case MULTISET:
24952           case SUBMULTISET:
24953           case LEADING:
24954           case TRAILING:
24955           case CHAR_CS:
24956           case NCHAR_CS:
24957           case DBTIMEZONE:
24958           case SESSIONTIMEZONE:
24959           case AUTHENTICATED:
24960           case LINK:
24961           case SHARED:
24962           case DIRECTORY:
24963           case USER:
24964           case IDENTIFIER:
24965           case QUOTED_LITERAL:
24966           case SQLDATA_CLASS:
24967           case CUSTOMDATUM_CLASS:
24968           case ORADATA_CLASS:
24969           case JAVA_INTERFACE_CLASS:
24970             ;
24971             break;
24972           default:
24973             jj_la1[356] = jj_gen;
24974             break label_76;
24975           }
24976           if (jj_2_68(2)) {
24977             TypeMethod();
24978           } else {
24979             switch (jj_nt.kind) {
24980             case REPLACE:
24981             case DEFINER:
24982             case CURRENT_USER:
24983             case SERIALLY_REUSABLE:
24984             case RESTRICT_REFERENCES:
24985             case EXCEPTION_INIT:
24986             case AUTONOMOUS_TRANSACTION:
24987             case LANGUAGE:
24988             case INLINE:
24989             case ADD:
24990             case AGGREGATE:
24991             case ALL:
24992             case ALTER:
24993             case AND:
24994             case ANY:
24995             case ARRAY:
24996             case AS:
24997             case ASC:
24998             case AT:
24999             case ATTRIBUTE:
25000             case AUTHID:
25001             case AVG:
25002             case BETWEEN:
25003             case BINARY_INTEGER:
25004             case BODY:
25005             case BOOLEAN:
25006             case BULK:
25007             case BY:
25008             case BYTE:
25009             case CASCADE:
25010             case CASE:
25011             case CHAR:
25012             case CHAR_BASE:
25013             case CHECK:
25014             case CLOSE:
25015             case CLUSTER:
25016             case COALESCE:
25017             case COLLECT:
25018             case COLUMN:
25019             case COMMENT:
25020             case COMMIT:
25021             case COMPRESS:
25022             case CONNECT:
25023             case CONSTANT:
25024             case CONSTRUCTOR:
25025             case CONTINUE:
25026             case CONVERT:
25027             case CREATE:
25028             case CURRENT:
25029             case CURRVAL:
25030             case CURSOR:
25031             case DATA:
25032             case DATE:
25033             case DAY:
25034             case DECLARE:
25035             case DECIMAL:
25036             case _DEFAULT:
25037             case DELETE:
25038             case DESC:
25039             case DISABLE:
25040             case DISTINCT:
25041             case DO:
25042             case DROP:
25043             case EDITIONABLE:
25044             case ELEMENT:
25045             case ELSE:
25046             case ELSIF:
25047             case ENABLE:
25048             case ESCAPE:
25049             case EXCEPT:
25050             case EXCEPTION:
25051             case EXCEPTIONS:
25052             case EXCLUSIVE:
25053             case EXECUTE:
25054             case EXISTS:
25055             case EXIT:
25056             case EXTERNAL:
25057             case EXTENDS:
25058             case EXTRACT:
25059             case FALSE:
25060             case FETCH:
25061             case FINAL:
25062             case FLOAT:
25063             case FOR:
25064             case FORALL:
25065             case FORCE:
25066             case FROM:
25067             case FUNCTION:
25068             case GLOBAL:
25069             case GOTO:
25070             case GROUP:
25071             case HASH:
25072             case HAVING:
25073             case HEAP:
25074             case HOUR:
25075             case IF:
25076             case IMMEDIATE:
25077             case IN:
25078             case INDEX:
25079             case INDICES:
25080             case INDEXTYPE:
25081             case INDICATOR:
25082             case INSERT:
25083             case INSTANTIABLE:
25084             case INTEGER:
25085             case INTERFACE:
25086             case INTERSECT:
25087             case INTERVAL:
25088             case INTO:
25089             case INVALIDATE:
25090             case IS:
25091             case ISOLATION:
25092             case JAVA:
25093             case LEVEL:
25094             case LIKE:
25095             case LIMIT:
25096             case LIMITED:
25097             case LOCK:
25098             case LONG:
25099             case LOOP:
25100             case MAP:
25101             case MAX:
25102             case MEMBER:
25103             case MERGE:
25104             case MIN:
25105             case MINUS:
25106             case MINUTE:
25107             case MLSLABEL:
25108             case MODIFY:
25109             case MOD:
25110             case MODE:
25111             case MONTH:
25112             case NATURAL:
25113             case NATURALN:
25114             case NEW:
25115             case NEXTVAL:
25116             case NO:
25117             case NOCOPY:
25118             case NONEDITIONABLE:
25119             case NOT:
25120             case NOWAIT:
25121             case NULL:
25122             case NULLIF:
25123             case NUMBER:
25124             case BFILE_BASE:
25125             case BLOB_BASE:
25126             case CLOB_BASE:
25127             case DATE_BASE:
25128             case NUMBER_BASE:
25129             case OBJECT:
25130             case OCIROWID:
25131             case OF:
25132             case OID:
25133             case ON:
25134             case OPAQUE:
25135             case OPEN:
25136             case OPERATOR:
25137             case OPTION:
25138             case OR:
25139             case ORDER:
25140             case ORGANIZATION:
25141             case OTHERS:
25142             case OUT:
25143             case OVERRIDING:
25144             case PACKAGE:
25145             case PARTITION:
25146             case PCTFREE:
25147             case PLS_INTEGER:
25148             case POSITIVE:
25149             case POSITIVEN:
25150             case PRESERVE:
25151             case PRIOR:
25152             case PROMPT:
25153             case PRIVATE:
25154             case PROCEDURE:
25155             case PUBLIC:
25156             case RAISE:
25157             case RANGE:
25158             case RAW:
25159             case REAL:
25160             case RECORD:
25161             case REF:
25162             case RELEASE:
25163             case RELIES_ON:
25164             case RENAME:
25165             case RESULT:
25166             case RETURN:
25167             case RETURNING:
25168             case REVERSE:
25169             case ROLLBACK:
25170             case ROW:
25171             case ROWS:
25172             case ROWID:
25173             case ROWNUM:
25174             case ROWTYPE:
25175             case SAVE:
25176             case SAVEPOINT:
25177             case SECOND:
25178             case SELECT:
25179             case SELF:
25180             case SEPARATE:
25181             case SET:
25182             case SHARE:
25183             case SMALLINT:
25184             case SPACE:
25185             case SQL:
25186             case SQLCODE:
25187             case SQLERRM:
25188             case START:
25189             case STATIC:
25190             case STDDEV:
25191             case SUBTYPE:
25192             case SUBSTITUTABLE:
25193             case SUCCESSFUL:
25194             case SUM:
25195             case SYNONYM:
25196             case SYSDATE:
25197             case SYS_REFCURSOR:
25198             case TABLE:
25199             case TEMPORARY:
25200             case THEN:
25201             case TIME:
25202             case TIMESTAMP:
25203             case TIMEZONE_REGION:
25204             case TIMEZONE_ABBR:
25205             case TIMEZONE_MINUTE:
25206             case TIMEZONE_HOUR:
25207             case TO:
25208             case TRANSACTION:
25209             case TRIGGER:
25210             case TRUE:
25211             case TYPE:
25212             case UI:
25213             case UNDER:
25214             case USING:
25215             case WHILE:
25216             case YES:
25217             case SHOW:
25218             case A:
25219             case UPDATE:
25220             case VARCHAR:
25221             case VARCHAR2:
25222             case DOUBLE:
25223             case DEC:
25224             case PRECISION:
25225             case INT:
25226             case NUMERIC:
25227             case SIGNTYPE:
25228             case NCHAR:
25229             case NVARCHAR2:
25230             case STRING:
25231             case UROWID:
25232             case VARRAY:
25233             case VARYING:
25234             case BFILE:
25235             case BLOB:
25236             case CLOB:
25237             case NCLOB:
25238             case YEAR:
25239             case LOCAL:
25240             case WITH:
25241             case ZONE:
25242             case CHARACTER:
25243             case AFTER:
25244             case BEFORE:
25245             case OLD:
25246             case PARENT:
25247             case ANALYZE:
25248             case ASSOCIATE:
25249             case AUDIT:
25250             case COMPOUND:
25251             case DATABASE:
25252             case CALL:
25253             case DDL:
25254             case DISASSOCIATE:
25255             case EACH:
25256             case FOLLOWS:
25257             case LOGOFF:
25258             case LOGON:
25259             case NESTED:
25260             case NOAUDIT:
25261             case SCHEMA:
25262             case SERVERERROR:
25263             case SHUTDOWN:
25264             case STARTUP:
25265             case STATEMENT:
25266             case STATISTICS:
25267             case SUSPEND:
25268             case TRUNCATE:
25269             case WRAPPED:
25270             case LIBRARY:
25271             case NAME:
25272             case STRUCT:
25273             case CONTEXT:
25274             case PARAMETERS:
25275             case LENGTH:
25276             case TDO:
25277             case MAXLEN:
25278             case CHARSETID:
25279             case CHARSETFORM:
25280             case ACCEPT:
25281             case ACCESSIBLE:
25282             case COPY:
25283             case DEFINE:
25284             case DISCONNECT:
25285             case HOST:
25286             case PRINT:
25287             case QUIT:
25288             case REMARK:
25289             case UNDEFINE:
25290             case VARIABLE:
25291             case WHENEVER:
25292             case ATTACH:
25293             case CAST:
25294             case TREAT:
25295             case TRIM:
25296             case LEFT:
25297             case RIGHT:
25298             case BOTH:
25299             case EMPTY:
25300             case MULTISET:
25301             case SUBMULTISET:
25302             case LEADING:
25303             case TRAILING:
25304             case CHAR_CS:
25305             case NCHAR_CS:
25306             case DBTIMEZONE:
25307             case SESSIONTIMEZONE:
25308             case AUTHENTICATED:
25309             case LINK:
25310             case SHARED:
25311             case DIRECTORY:
25312             case USER:
25313             case IDENTIFIER:
25314             case QUOTED_LITERAL:
25315             case SQLDATA_CLASS:
25316             case CUSTOMDATUM_CLASS:
25317             case ORADATA_CLASS:
25318             case JAVA_INTERFACE_CLASS:
25319               AttributeDeclaration();
25320               break;
25321             case PRAGMA:
25322               PragmaClause();
25323               break;
25324             default:
25325               jj_la1[357] = jj_gen;
25326               jj_consume_token(-1);
25327               throw new ParseException();
25328             }
25329           }
25330         }
25331         label_77:
25332         while (true) {
25333           switch (jj_nt.kind) {
25334           case 6:
25335             ;
25336             break;
25337           default:
25338             jj_la1[358] = jj_gen;
25339             break label_77;
25340           }
25341           jj_consume_token(6);
25342           switch (jj_nt.kind) {
25343           case CONSTRUCTOR:
25344           case FINAL:
25345           case INSTANTIABLE:
25346           case MAP:
25347           case MEMBER:
25348           case NOT:
25349           case ORDER:
25350           case OVERRIDING:
25351           case STATIC:
25352             TypeMethod();
25353             break;
25354           default:
25355             jj_la1[359] = jj_gen;
25356             if (jj_2_69(2)) {
25357               AttributeDeclaration();
25358             } else {
25359               switch (jj_nt.kind) {
25360               case PRAGMA:
25361                 PragmaClause();
25362                 break;
25363               default:
25364                 jj_la1[360] = jj_gen;
25365                 jj_consume_token(-1);
25366                 throw new ParseException();
25367               }
25368             }
25369           }
25370         }
25371         jj_consume_token(7);
25372         break;
25373       default:
25374         jj_la1[361] = jj_gen;
25375         ;
25376       }
25377       label_78:
25378       while (true) {
25379         switch (jj_nt.kind) {
25380         case FINAL:
25381         case INSTANTIABLE:
25382         case NOT:
25383         case NULL:
25384           ;
25385           break;
25386         default:
25387           jj_la1[362] = jj_gen;
25388           break label_78;
25389         }
25390         switch (jj_nt.kind) {
25391         case NOT:
25392           jj_consume_token(NOT);
25393           break;
25394         default:
25395           jj_la1[363] = jj_gen;
25396           ;
25397         }
25398         switch (jj_nt.kind) {
25399         case FINAL:
25400           jj_consume_token(FINAL);
25401           break;
25402         case INSTANTIABLE:
25403           jj_consume_token(INSTANTIABLE);
25404           break;
25405         case NULL:
25406           jj_consume_token(NULL);
25407           break;
25408         default:
25409           jj_la1[364] = jj_gen;
25410           jj_consume_token(-1);
25411           throw new ParseException();
25412         }
25413       }
25414       label_79:
25415       while (true) {
25416         switch (jj_nt.kind) {
25417         case ALTER:
25418           ;
25419           break;
25420         default:
25421           jj_la1[365] = jj_gen;
25422           break label_79;
25423         }
25424         AlterTypeSpec();
25425       }
25426       switch (jj_nt.kind) {
25427       case 1:
25428       case 4:
25429         switch (jj_nt.kind) {
25430         case 4:
25431           jj_consume_token(4);
25432           break;
25433         case 1:
25434           jj_consume_token(1);
25435           break;
25436         default:
25437           jj_la1[366] = jj_gen;
25438           jj_consume_token(-1);
25439           throw new ParseException();
25440         }
25441         label_80:
25442         while (true) {
25443           switch (jj_nt.kind) {
25444           case ALTER:
25445             ;
25446             break;
25447           default:
25448             jj_la1[367] = jj_gen;
25449             break label_80;
25450           }
25451           AlterTypeSpec();
25452           switch (jj_nt.kind) {
25453           case 1:
25454             jj_consume_token(1);
25455             break;
25456           case 4:
25457             jj_consume_token(4);
25458             break;
25459           default:
25460             jj_la1[368] = jj_gen;
25461             jj_consume_token(-1);
25462             throw new ParseException();
25463           }
25464         }
25465         break;
25466       default:
25467         jj_la1[369] = jj_gen;
25468         ;
25469       }
25470         jjtree.closeNodeScope(jjtn000, true);
25471         jjtc000 = false;
25472         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
25473     } catch (Throwable jjte000) {
25474           if (jjtc000) {
25475             jjtree.clearNodeScope(jjtn000);
25476             jjtc000 = false;
25477           } else {
25478             jjtree.popNode();
25479           }
25480           if (jjte000 instanceof RuntimeException) {
25481             {if (true) throw (RuntimeException)jjte000;}
25482           }
25483           if (jjte000 instanceof ParseException) {
25484             {if (true) throw (ParseException)jjte000;}
25485           }
25486           {if (true) throw (Error)jjte000;}
25487     } finally {
25488           if (jjtc000) {
25489             jjtree.closeNodeScope(jjtn000, true);
25490           }
25491     }
25492     throw new Error("Missing return statement in function");
25493   }
25494 
25495   final public ASTAlterTypeSpec AlterTypeSpec() throws ParseException {
25496  /*@bgen(jjtree) AlterTypeSpec */
25497  ASTAlterTypeSpec jjtn000 = new ASTAlterTypeSpec(this, JJTALTERTYPESPEC);
25498  boolean jjtc000 = true;
25499  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
25500     try {
25501       jj_consume_token(ALTER);
25502       jj_consume_token(TYPE);
25503       simpleNode = QualifiedName();
25504       label_81:
25505       while (true) {
25506         switch (jj_nt.kind) {
25507         case 6:
25508         case ADD:
25509         case DROP:
25510         case MODIFY:
25511           ;
25512           break;
25513         default:
25514           jj_la1[370] = jj_gen;
25515           break label_81;
25516         }
25517         switch (jj_nt.kind) {
25518         case 6:
25519         case ADD:
25520         case MODIFY:
25521           switch (jj_nt.kind) {
25522           case 6:
25523             jj_consume_token(6);
25524             break;
25525           default:
25526             jj_la1[371] = jj_gen;
25527             ;
25528           }
25529           switch (jj_nt.kind) {
25530           case ADD:
25531             jj_consume_token(ADD);
25532             break;
25533           case MODIFY:
25534             jj_consume_token(MODIFY);
25535             break;
25536           default:
25537             jj_la1[372] = jj_gen;
25538             jj_consume_token(-1);
25539             throw new ParseException();
25540           }
25541           label_82:
25542           while (true) {
25543             switch (jj_nt.kind) {
25544             case CONSTRUCTOR:
25545             case FINAL:
25546             case INSTANTIABLE:
25547             case MAP:
25548             case MEMBER:
25549             case NOT:
25550             case ORDER:
25551             case OVERRIDING:
25552             case STATIC:
25553               TypeMethod();
25554               break;
25555             case ATTRIBUTE:
25556               jj_consume_token(ATTRIBUTE);
25557               label_83:
25558               while (true) {
25559                 switch (jj_nt.kind) {
25560                 case 5:
25561                   ;
25562                   break;
25563                 default:
25564                   jj_la1[373] = jj_gen;
25565                   break label_83;
25566                 }
25567                 jj_consume_token(5);
25568               }
25569               AttributeDeclaration();
25570               label_84:
25571               while (true) {
25572                 switch (jj_nt.kind) {
25573                 case 6:
25574                   ;
25575                   break;
25576                 default:
25577                   jj_la1[374] = jj_gen;
25578                   break label_84;
25579                 }
25580                 jj_consume_token(6);
25581                 AttributeDeclaration();
25582               }
25583               label_85:
25584               while (true) {
25585                 switch (jj_nt.kind) {
25586                 case 7:
25587                   ;
25588                   break;
25589                 default:
25590                   jj_la1[375] = jj_gen;
25591                   break label_85;
25592                 }
25593                 jj_consume_token(7);
25594               }
25595               break;
25596             case LIMIT:
25597               jj_consume_token(LIMIT);
25598               NumericLiteral();
25599               break;
25600             case ELEMENT:
25601               jj_consume_token(ELEMENT);
25602               jj_consume_token(TYPE);
25603               Datatype();
25604               break;
25605             default:
25606               jj_la1[376] = jj_gen;
25607               jj_consume_token(-1);
25608               throw new ParseException();
25609             }
25610             switch (jj_nt.kind) {
25611             case ATTRIBUTE:
25612             case CONSTRUCTOR:
25613             case ELEMENT:
25614             case FINAL:
25615             case INSTANTIABLE:
25616             case LIMIT:
25617             case MAP:
25618             case MEMBER:
25619             case NOT:
25620             case ORDER:
25621             case OVERRIDING:
25622             case STATIC:
25623               ;
25624               break;
25625             default:
25626               jj_la1[377] = jj_gen;
25627               break label_82;
25628             }
25629           }
25630           break;
25631         case DROP:
25632           jj_consume_token(DROP);
25633           label_86:
25634           while (true) {
25635             switch (jj_nt.kind) {
25636             case ATTRIBUTE:
25637               jj_consume_token(ATTRIBUTE);
25638               label_87:
25639               while (true) {
25640                 switch (jj_nt.kind) {
25641                 case 5:
25642                   ;
25643                   break;
25644                 default:
25645                   jj_la1[378] = jj_gen;
25646                   break label_87;
25647                 }
25648                 jj_consume_token(5);
25649               }
25650               Attribute();
25651               label_88:
25652               while (true) {
25653                 switch (jj_nt.kind) {
25654                 case 6:
25655                   ;
25656                   break;
25657                 default:
25658                   jj_la1[379] = jj_gen;
25659                   break label_88;
25660                 }
25661                 jj_consume_token(6);
25662                 Attribute();
25663               }
25664               label_89:
25665               while (true) {
25666                 switch (jj_nt.kind) {
25667                 case 7:
25668                   ;
25669                   break;
25670                 default:
25671                   jj_la1[380] = jj_gen;
25672                   break label_89;
25673                 }
25674                 jj_consume_token(7);
25675               }
25676               break;
25677             case CONSTRUCTOR:
25678             case FINAL:
25679             case INSTANTIABLE:
25680             case MAP:
25681             case MEMBER:
25682             case NOT:
25683             case ORDER:
25684             case OVERRIDING:
25685             case STATIC:
25686               TypeMethod();
25687               break;
25688             default:
25689               jj_la1[381] = jj_gen;
25690               jj_consume_token(-1);
25691               throw new ParseException();
25692             }
25693             switch (jj_nt.kind) {
25694             case ATTRIBUTE:
25695             case CONSTRUCTOR:
25696             case FINAL:
25697             case INSTANTIABLE:
25698             case MAP:
25699             case MEMBER:
25700             case NOT:
25701             case ORDER:
25702             case OVERRIDING:
25703             case STATIC:
25704               ;
25705               break;
25706             default:
25707               jj_la1[382] = jj_gen;
25708               break label_86;
25709             }
25710           }
25711           break;
25712         default:
25713           jj_la1[383] = jj_gen;
25714           jj_consume_token(-1);
25715           throw new ParseException();
25716         }
25717       }
25718       switch (jj_nt.kind) {
25719       case REPLACE:
25720         jj_consume_token(REPLACE);
25721         label_90:
25722         while (true) {
25723           if (jj_2_70(2)) {
25724             ;
25725           } else {
25726             break label_90;
25727           }
25728           switch (jj_nt.kind) {
25729           case AUTHID:
25730             jj_consume_token(AUTHID);
25731             switch (jj_nt.kind) {
25732             case CURRENT_USER:
25733               jj_consume_token(CURRENT_USER);
25734               break;
25735             case DEFINER:
25736               jj_consume_token(DEFINER);
25737               break;
25738             default:
25739               jj_la1[384] = jj_gen;
25740               jj_consume_token(-1);
25741               throw new ParseException();
25742             }
25743             break;
25744           case ACCESSIBLE:
25745             AccessibleByClause();
25746             break;
25747           default:
25748             jj_la1[385] = jj_gen;
25749             jj_consume_token(-1);
25750             throw new ParseException();
25751           }
25752         }
25753         switch (jj_nt.kind) {
25754         case IS:
25755           jj_consume_token(IS);
25756           break;
25757         case AS:
25758           jj_consume_token(AS);
25759           break;
25760         default:
25761           jj_la1[386] = jj_gen;
25762           jj_consume_token(-1);
25763           throw new ParseException();
25764         }
25765         jj_consume_token(OBJECT);
25766         jj_consume_token(5);
25767         if (jj_2_71(2)) {
25768           TypeMethod();
25769         } else {
25770           switch (jj_nt.kind) {
25771           case REPLACE:
25772           case DEFINER:
25773           case CURRENT_USER:
25774           case SERIALLY_REUSABLE:
25775           case RESTRICT_REFERENCES:
25776           case EXCEPTION_INIT:
25777           case AUTONOMOUS_TRANSACTION:
25778           case LANGUAGE:
25779           case INLINE:
25780           case ADD:
25781           case AGGREGATE:
25782           case ALL:
25783           case ALTER:
25784           case AND:
25785           case ANY:
25786           case ARRAY:
25787           case AS:
25788           case ASC:
25789           case AT:
25790           case ATTRIBUTE:
25791           case AUTHID:
25792           case AVG:
25793           case BETWEEN:
25794           case BINARY_INTEGER:
25795           case BODY:
25796           case BOOLEAN:
25797           case BULK:
25798           case BY:
25799           case BYTE:
25800           case CASCADE:
25801           case CASE:
25802           case CHAR:
25803           case CHAR_BASE:
25804           case CHECK:
25805           case CLOSE:
25806           case CLUSTER:
25807           case COALESCE:
25808           case COLLECT:
25809           case COLUMN:
25810           case COMMENT:
25811           case COMMIT:
25812           case COMPRESS:
25813           case CONNECT:
25814           case CONSTANT:
25815           case CONSTRUCTOR:
25816           case CONTINUE:
25817           case CONVERT:
25818           case CREATE:
25819           case CURRENT:
25820           case CURRVAL:
25821           case CURSOR:
25822           case DATA:
25823           case DATE:
25824           case DAY:
25825           case DECLARE:
25826           case DECIMAL:
25827           case _DEFAULT:
25828           case DELETE:
25829           case DESC:
25830           case DISABLE:
25831           case DISTINCT:
25832           case DO:
25833           case DROP:
25834           case EDITIONABLE:
25835           case ELEMENT:
25836           case ELSE:
25837           case ELSIF:
25838           case ENABLE:
25839           case ESCAPE:
25840           case EXCEPT:
25841           case EXCEPTION:
25842           case EXCEPTIONS:
25843           case EXCLUSIVE:
25844           case EXECUTE:
25845           case EXISTS:
25846           case EXIT:
25847           case EXTERNAL:
25848           case EXTENDS:
25849           case EXTRACT:
25850           case FALSE:
25851           case FETCH:
25852           case FINAL:
25853           case FLOAT:
25854           case FOR:
25855           case FORALL:
25856           case FORCE:
25857           case FROM:
25858           case FUNCTION:
25859           case GLOBAL:
25860           case GOTO:
25861           case GROUP:
25862           case HASH:
25863           case HAVING:
25864           case HEAP:
25865           case HOUR:
25866           case IF:
25867           case IMMEDIATE:
25868           case IN:
25869           case INDEX:
25870           case INDICES:
25871           case INDEXTYPE:
25872           case INDICATOR:
25873           case INSERT:
25874           case INSTANTIABLE:
25875           case INTEGER:
25876           case INTERFACE:
25877           case INTERSECT:
25878           case INTERVAL:
25879           case INTO:
25880           case INVALIDATE:
25881           case IS:
25882           case ISOLATION:
25883           case JAVA:
25884           case LEVEL:
25885           case LIKE:
25886           case LIMIT:
25887           case LIMITED:
25888           case LOCK:
25889           case LONG:
25890           case LOOP:
25891           case MAP:
25892           case MAX:
25893           case MEMBER:
25894           case MERGE:
25895           case MIN:
25896           case MINUS:
25897           case MINUTE:
25898           case MLSLABEL:
25899           case MODIFY:
25900           case MOD:
25901           case MODE:
25902           case MONTH:
25903           case NATURAL:
25904           case NATURALN:
25905           case NEW:
25906           case NEXTVAL:
25907           case NO:
25908           case NOCOPY:
25909           case NONEDITIONABLE:
25910           case NOT:
25911           case NOWAIT:
25912           case NULL:
25913           case NULLIF:
25914           case NUMBER:
25915           case BFILE_BASE:
25916           case BLOB_BASE:
25917           case CLOB_BASE:
25918           case DATE_BASE:
25919           case NUMBER_BASE:
25920           case OBJECT:
25921           case OCIROWID:
25922           case OF:
25923           case OID:
25924           case ON:
25925           case OPAQUE:
25926           case OPEN:
25927           case OPERATOR:
25928           case OPTION:
25929           case OR:
25930           case ORDER:
25931           case ORGANIZATION:
25932           case OTHERS:
25933           case OUT:
25934           case OVERRIDING:
25935           case PACKAGE:
25936           case PARTITION:
25937           case PCTFREE:
25938           case PLS_INTEGER:
25939           case POSITIVE:
25940           case POSITIVEN:
25941           case PRESERVE:
25942           case PRIOR:
25943           case PROMPT:
25944           case PRIVATE:
25945           case PROCEDURE:
25946           case PUBLIC:
25947           case RAISE:
25948           case RANGE:
25949           case RAW:
25950           case REAL:
25951           case RECORD:
25952           case REF:
25953           case RELEASE:
25954           case RELIES_ON:
25955           case RENAME:
25956           case RESULT:
25957           case RETURN:
25958           case RETURNING:
25959           case REVERSE:
25960           case ROLLBACK:
25961           case ROW:
25962           case ROWS:
25963           case ROWID:
25964           case ROWNUM:
25965           case ROWTYPE:
25966           case SAVE:
25967           case SAVEPOINT:
25968           case SECOND:
25969           case SELECT:
25970           case SELF:
25971           case SEPARATE:
25972           case SET:
25973           case SHARE:
25974           case SMALLINT:
25975           case SPACE:
25976           case SQL:
25977           case SQLCODE:
25978           case SQLERRM:
25979           case START:
25980           case STATIC:
25981           case STDDEV:
25982           case SUBTYPE:
25983           case SUBSTITUTABLE:
25984           case SUCCESSFUL:
25985           case SUM:
25986           case SYNONYM:
25987           case SYSDATE:
25988           case SYS_REFCURSOR:
25989           case TABLE:
25990           case TEMPORARY:
25991           case THEN:
25992           case TIME:
25993           case TIMESTAMP:
25994           case TIMEZONE_REGION:
25995           case TIMEZONE_ABBR:
25996           case TIMEZONE_MINUTE:
25997           case TIMEZONE_HOUR:
25998           case TO:
25999           case TRANSACTION:
26000           case TRIGGER:
26001           case TRUE:
26002           case TYPE:
26003           case UI:
26004           case UNDER:
26005           case USING:
26006           case WHILE:
26007           case YES:
26008           case SHOW:
26009           case A:
26010           case UPDATE:
26011           case VARCHAR:
26012           case VARCHAR2:
26013           case DOUBLE:
26014           case DEC:
26015           case PRECISION:
26016           case INT:
26017           case NUMERIC:
26018           case SIGNTYPE:
26019           case NCHAR:
26020           case NVARCHAR2:
26021           case STRING:
26022           case UROWID:
26023           case VARRAY:
26024           case VARYING:
26025           case BFILE:
26026           case BLOB:
26027           case CLOB:
26028           case NCLOB:
26029           case YEAR:
26030           case LOCAL:
26031           case WITH:
26032           case ZONE:
26033           case CHARACTER:
26034           case AFTER:
26035           case BEFORE:
26036           case OLD:
26037           case PARENT:
26038           case ANALYZE:
26039           case ASSOCIATE:
26040           case AUDIT:
26041           case COMPOUND:
26042           case DATABASE:
26043           case CALL:
26044           case DDL:
26045           case DISASSOCIATE:
26046           case EACH:
26047           case FOLLOWS:
26048           case LOGOFF:
26049           case LOGON:
26050           case NESTED:
26051           case NOAUDIT:
26052           case SCHEMA:
26053           case SERVERERROR:
26054           case SHUTDOWN:
26055           case STARTUP:
26056           case STATEMENT:
26057           case STATISTICS:
26058           case SUSPEND:
26059           case TRUNCATE:
26060           case WRAPPED:
26061           case LIBRARY:
26062           case NAME:
26063           case STRUCT:
26064           case CONTEXT:
26065           case PARAMETERS:
26066           case LENGTH:
26067           case TDO:
26068           case MAXLEN:
26069           case CHARSETID:
26070           case CHARSETFORM:
26071           case ACCEPT:
26072           case ACCESSIBLE:
26073           case COPY:
26074           case DEFINE:
26075           case DISCONNECT:
26076           case HOST:
26077           case PRINT:
26078           case QUIT:
26079           case REMARK:
26080           case UNDEFINE:
26081           case VARIABLE:
26082           case WHENEVER:
26083           case ATTACH:
26084           case CAST:
26085           case TREAT:
26086           case TRIM:
26087           case LEFT:
26088           case RIGHT:
26089           case BOTH:
26090           case EMPTY:
26091           case MULTISET:
26092           case SUBMULTISET:
26093           case LEADING:
26094           case TRAILING:
26095           case CHAR_CS:
26096           case NCHAR_CS:
26097           case DBTIMEZONE:
26098           case SESSIONTIMEZONE:
26099           case AUTHENTICATED:
26100           case LINK:
26101           case SHARED:
26102           case DIRECTORY:
26103           case USER:
26104           case IDENTIFIER:
26105           case QUOTED_LITERAL:
26106           case SQLDATA_CLASS:
26107           case CUSTOMDATUM_CLASS:
26108           case ORADATA_CLASS:
26109           case JAVA_INTERFACE_CLASS:
26110             AttributeDeclaration();
26111             break;
26112           default:
26113             jj_la1[387] = jj_gen;
26114             jj_consume_token(-1);
26115             throw new ParseException();
26116           }
26117         }
26118         label_91:
26119         while (true) {
26120           switch (jj_nt.kind) {
26121           case 6:
26122             ;
26123             break;
26124           default:
26125             jj_la1[388] = jj_gen;
26126             break label_91;
26127           }
26128           jj_consume_token(6);
26129           if (jj_2_72(2)) {
26130             TypeMethod();
26131           } else {
26132             switch (jj_nt.kind) {
26133             case REPLACE:
26134             case DEFINER:
26135             case CURRENT_USER:
26136             case SERIALLY_REUSABLE:
26137             case RESTRICT_REFERENCES:
26138             case EXCEPTION_INIT:
26139             case AUTONOMOUS_TRANSACTION:
26140             case LANGUAGE:
26141             case INLINE:
26142             case ADD:
26143             case AGGREGATE:
26144             case ALL:
26145             case ALTER:
26146             case AND:
26147             case ANY:
26148             case ARRAY:
26149             case AS:
26150             case ASC:
26151             case AT:
26152             case ATTRIBUTE:
26153             case AUTHID:
26154             case AVG:
26155             case BETWEEN:
26156             case BINARY_INTEGER:
26157             case BODY:
26158             case BOOLEAN:
26159             case BULK:
26160             case BY:
26161             case BYTE:
26162             case CASCADE:
26163             case CASE:
26164             case CHAR:
26165             case CHAR_BASE:
26166             case CHECK:
26167             case CLOSE:
26168             case CLUSTER:
26169             case COALESCE:
26170             case COLLECT:
26171             case COLUMN:
26172             case COMMENT:
26173             case COMMIT:
26174             case COMPRESS:
26175             case CONNECT:
26176             case CONSTANT:
26177             case CONSTRUCTOR:
26178             case CONTINUE:
26179             case CONVERT:
26180             case CREATE:
26181             case CURRENT:
26182             case CURRVAL:
26183             case CURSOR:
26184             case DATA:
26185             case DATE:
26186             case DAY:
26187             case DECLARE:
26188             case DECIMAL:
26189             case _DEFAULT:
26190             case DELETE:
26191             case DESC:
26192             case DISABLE:
26193             case DISTINCT:
26194             case DO:
26195             case DROP:
26196             case EDITIONABLE:
26197             case ELEMENT:
26198             case ELSE:
26199             case ELSIF:
26200             case ENABLE:
26201             case ESCAPE:
26202             case EXCEPT:
26203             case EXCEPTION:
26204             case EXCEPTIONS:
26205             case EXCLUSIVE:
26206             case EXECUTE:
26207             case EXISTS:
26208             case EXIT:
26209             case EXTERNAL:
26210             case EXTENDS:
26211             case EXTRACT:
26212             case FALSE:
26213             case FETCH:
26214             case FINAL:
26215             case FLOAT:
26216             case FOR:
26217             case FORALL:
26218             case FORCE:
26219             case FROM:
26220             case FUNCTION:
26221             case GLOBAL:
26222             case GOTO:
26223             case GROUP:
26224             case HASH:
26225             case HAVING:
26226             case HEAP:
26227             case HOUR:
26228             case IF:
26229             case IMMEDIATE:
26230             case IN:
26231             case INDEX:
26232             case INDICES:
26233             case INDEXTYPE:
26234             case INDICATOR:
26235             case INSERT:
26236             case INSTANTIABLE:
26237             case INTEGER:
26238             case INTERFACE:
26239             case INTERSECT:
26240             case INTERVAL:
26241             case INTO:
26242             case INVALIDATE:
26243             case IS:
26244             case ISOLATION:
26245             case JAVA:
26246             case LEVEL:
26247             case LIKE:
26248             case LIMIT:
26249             case LIMITED:
26250             case LOCK:
26251             case LONG:
26252             case LOOP:
26253             case MAP:
26254             case MAX:
26255             case MEMBER:
26256             case MERGE:
26257             case MIN:
26258             case MINUS:
26259             case MINUTE:
26260             case MLSLABEL:
26261             case MODIFY:
26262             case MOD:
26263             case MODE:
26264             case MONTH:
26265             case NATURAL:
26266             case NATURALN:
26267             case NEW:
26268             case NEXTVAL:
26269             case NO:
26270             case NOCOPY:
26271             case NONEDITIONABLE:
26272             case NOT:
26273             case NOWAIT:
26274             case NULL:
26275             case NULLIF:
26276             case NUMBER:
26277             case BFILE_BASE:
26278             case BLOB_BASE:
26279             case CLOB_BASE:
26280             case DATE_BASE:
26281             case NUMBER_BASE:
26282             case OBJECT:
26283             case OCIROWID:
26284             case OF:
26285             case OID:
26286             case ON:
26287             case OPAQUE:
26288             case OPEN:
26289             case OPERATOR:
26290             case OPTION:
26291             case OR:
26292             case ORDER:
26293             case ORGANIZATION:
26294             case OTHERS:
26295             case OUT:
26296             case OVERRIDING:
26297             case PACKAGE:
26298             case PARTITION:
26299             case PCTFREE:
26300             case PLS_INTEGER:
26301             case POSITIVE:
26302             case POSITIVEN:
26303             case PRESERVE:
26304             case PRIOR:
26305             case PROMPT:
26306             case PRIVATE:
26307             case PROCEDURE:
26308             case PUBLIC:
26309             case RAISE:
26310             case RANGE:
26311             case RAW:
26312             case REAL:
26313             case RECORD:
26314             case REF:
26315             case RELEASE:
26316             case RELIES_ON:
26317             case RENAME:
26318             case RESULT:
26319             case RETURN:
26320             case RETURNING:
26321             case REVERSE:
26322             case ROLLBACK:
26323             case ROW:
26324             case ROWS:
26325             case ROWID:
26326             case ROWNUM:
26327             case ROWTYPE:
26328             case SAVE:
26329             case SAVEPOINT:
26330             case SECOND:
26331             case SELECT:
26332             case SELF:
26333             case SEPARATE:
26334             case SET:
26335             case SHARE:
26336             case SMALLINT:
26337             case SPACE:
26338             case SQL:
26339             case SQLCODE:
26340             case SQLERRM:
26341             case START:
26342             case STATIC:
26343             case STDDEV:
26344             case SUBTYPE:
26345             case SUBSTITUTABLE:
26346             case SUCCESSFUL:
26347             case SUM:
26348             case SYNONYM:
26349             case SYSDATE:
26350             case SYS_REFCURSOR:
26351             case TABLE:
26352             case TEMPORARY:
26353             case THEN:
26354             case TIME:
26355             case TIMESTAMP:
26356             case TIMEZONE_REGION:
26357             case TIMEZONE_ABBR:
26358             case TIMEZONE_MINUTE:
26359             case TIMEZONE_HOUR:
26360             case TO:
26361             case TRANSACTION:
26362             case TRIGGER:
26363             case TRUE:
26364             case TYPE:
26365             case UI:
26366             case UNDER:
26367             case USING:
26368             case WHILE:
26369             case YES:
26370             case SHOW:
26371             case A:
26372             case UPDATE:
26373             case VARCHAR:
26374             case VARCHAR2:
26375             case DOUBLE:
26376             case DEC:
26377             case PRECISION:
26378             case INT:
26379             case NUMERIC:
26380             case SIGNTYPE:
26381             case NCHAR:
26382             case NVARCHAR2:
26383             case STRING:
26384             case UROWID:
26385             case VARRAY:
26386             case VARYING:
26387             case BFILE:
26388             case BLOB:
26389             case CLOB:
26390             case NCLOB:
26391             case YEAR:
26392             case LOCAL:
26393             case WITH:
26394             case ZONE:
26395             case CHARACTER:
26396             case AFTER:
26397             case BEFORE:
26398             case OLD:
26399             case PARENT:
26400             case ANALYZE:
26401             case ASSOCIATE:
26402             case AUDIT:
26403             case COMPOUND:
26404             case DATABASE:
26405             case CALL:
26406             case DDL:
26407             case DISASSOCIATE:
26408             case EACH:
26409             case FOLLOWS:
26410             case LOGOFF:
26411             case LOGON:
26412             case NESTED:
26413             case NOAUDIT:
26414             case SCHEMA:
26415             case SERVERERROR:
26416             case SHUTDOWN:
26417             case STARTUP:
26418             case STATEMENT:
26419             case STATISTICS:
26420             case SUSPEND:
26421             case TRUNCATE:
26422             case WRAPPED:
26423             case LIBRARY:
26424             case NAME:
26425             case STRUCT:
26426             case CONTEXT:
26427             case PARAMETERS:
26428             case LENGTH:
26429             case TDO:
26430             case MAXLEN:
26431             case CHARSETID:
26432             case CHARSETFORM:
26433             case ACCEPT:
26434             case ACCESSIBLE:
26435             case COPY:
26436             case DEFINE:
26437             case DISCONNECT:
26438             case HOST:
26439             case PRINT:
26440             case QUIT:
26441             case REMARK:
26442             case UNDEFINE:
26443             case VARIABLE:
26444             case WHENEVER:
26445             case ATTACH:
26446             case CAST:
26447             case TREAT:
26448             case TRIM:
26449             case LEFT:
26450             case RIGHT:
26451             case BOTH:
26452             case EMPTY:
26453             case MULTISET:
26454             case SUBMULTISET:
26455             case LEADING:
26456             case TRAILING:
26457             case CHAR_CS:
26458             case NCHAR_CS:
26459             case DBTIMEZONE:
26460             case SESSIONTIMEZONE:
26461             case AUTHENTICATED:
26462             case LINK:
26463             case SHARED:
26464             case DIRECTORY:
26465             case USER:
26466             case IDENTIFIER:
26467             case QUOTED_LITERAL:
26468             case SQLDATA_CLASS:
26469             case CUSTOMDATUM_CLASS:
26470             case ORADATA_CLASS:
26471             case JAVA_INTERFACE_CLASS:
26472               AttributeDeclaration();
26473               break;
26474             default:
26475               jj_la1[389] = jj_gen;
26476               jj_consume_token(-1);
26477               throw new ParseException();
26478             }
26479           }
26480         }
26481         jj_consume_token(7);
26482         break;
26483       default:
26484         jj_la1[390] = jj_gen;
26485         ;
26486       }
26487       label_92:
26488       while (true) {
26489         switch (jj_nt.kind) {
26490         case FINAL:
26491         case INSTANTIABLE:
26492         case NOT:
26493         case NULL:
26494           ;
26495           break;
26496         default:
26497           jj_la1[391] = jj_gen;
26498           break label_92;
26499         }
26500         switch (jj_nt.kind) {
26501         case NOT:
26502           jj_consume_token(NOT);
26503           break;
26504         default:
26505           jj_la1[392] = jj_gen;
26506           ;
26507         }
26508         switch (jj_nt.kind) {
26509         case FINAL:
26510           jj_consume_token(FINAL);
26511           break;
26512         case INSTANTIABLE:
26513           jj_consume_token(INSTANTIABLE);
26514           break;
26515         case NULL:
26516           jj_consume_token(NULL);
26517           break;
26518         default:
26519           jj_la1[393] = jj_gen;
26520           jj_consume_token(-1);
26521           throw new ParseException();
26522         }
26523       }
26524       switch (jj_nt.kind) {
26525       case CASCADE:
26526       case INVALIDATE:
26527         switch (jj_nt.kind) {
26528         case INVALIDATE:
26529           jj_consume_token(INVALIDATE);
26530           break;
26531         case CASCADE:
26532           jj_consume_token(CASCADE);
26533           label_93:
26534           while (true) {
26535             switch (jj_nt.kind) {
26536             case CONVERT:
26537             case INCLUDING:
26538             case NOT:
26539               ;
26540               break;
26541             default:
26542               jj_la1[394] = jj_gen;
26543               break label_93;
26544             }
26545             switch (jj_nt.kind) {
26546             case INCLUDING:
26547             case NOT:
26548               switch (jj_nt.kind) {
26549               case NOT:
26550                 jj_consume_token(NOT);
26551                 break;
26552               default:
26553                 jj_la1[395] = jj_gen;
26554                 ;
26555               }
26556               jj_consume_token(INCLUDING);
26557               jj_consume_token(TABLE);
26558               jj_consume_token(DATA);
26559               break;
26560             case CONVERT:
26561               jj_consume_token(CONVERT);
26562               jj_consume_token(TO);
26563               jj_consume_token(SUBSTITUTABLE);
26564               break;
26565             default:
26566               jj_la1[396] = jj_gen;
26567               jj_consume_token(-1);
26568               throw new ParseException();
26569             }
26570           }
26571           switch (jj_nt.kind) {
26572           case EXCEPTIONS:
26573           case FORCE:
26574             switch (jj_nt.kind) {
26575             case FORCE:
26576               jj_consume_token(FORCE);
26577               break;
26578             default:
26579               jj_la1[397] = jj_gen;
26580               ;
26581             }
26582             jj_consume_token(EXCEPTIONS);
26583             jj_consume_token(INTO);
26584             QualifiedName();
26585             break;
26586           default:
26587             jj_la1[398] = jj_gen;
26588             ;
26589           }
26590           break;
26591         default:
26592           jj_la1[399] = jj_gen;
26593           jj_consume_token(-1);
26594           throw new ParseException();
26595         }
26596         break;
26597       default:
26598         jj_la1[400] = jj_gen;
26599         ;
26600       }
26601         jjtree.closeNodeScope(jjtn000, true);
26602         jjtc000 = false;
26603         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
26604     } catch (Throwable jjte000) {
26605           if (jjtc000) {
26606             jjtree.clearNodeScope(jjtn000);
26607             jjtc000 = false;
26608           } else {
26609             jjtree.popNode();
26610           }
26611           if (jjte000 instanceof RuntimeException) {
26612             {if (true) throw (RuntimeException)jjte000;}
26613           }
26614           if (jjte000 instanceof ParseException) {
26615             {if (true) throw (ParseException)jjte000;}
26616           }
26617           {if (true) throw (Error)jjte000;}
26618     } finally {
26619           if (jjtc000) {
26620             jjtree.closeNodeScope(jjtn000, true);
26621           }
26622     }
26623     throw new Error("Missing return statement in function");
26624   }
26625 
26626 /*
26627 ASTTypeBody TypeBody()  :
26628 { Token name=null; }
26629 {
26630 	[<CREATE> [<OR> <REPLACE>]]
26631 
26632 	<TYPE> <BODY> (LOOKAHEAD(2) ID()".")? name=ID()
26633 
26634 	(
26635 	  (
26636 	    WrappedObject() 
26637 	  )
26638 	  |
26639 	  (
26640 	    (<IS> | <AS>)
26641 
26642 		    DeclarativeSection() //SRT 20110524 Allow PLDOc in Type Bodies 
26643 
26644 	    [ <BEGIN> (Statement())* (ExceptionHandler())? ] <END> [ID()] ";" 
26645 	  )
26646 	)
26647 }
26648 */
26649 
26650 
26651 /**
26652   * Method 
26653 **/
26654   final public ASTAttributeDeclaration AttributeDeclaration() throws ParseException {
26655  /*@bgen(jjtree) AttributeDeclaration */
26656  ASTAttributeDeclaration jjtn000 = new ASTAttributeDeclaration(this, JJTATTRIBUTEDECLARATION);
26657  boolean jjtc000 = true;
26658  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26659     try {
26660       simpleNode = ID();
26661       Datatype();
26662         jjtree.closeNodeScope(jjtn000, true);
26663         jjtc000 = false;
26664         jjtn000.setImage(simpleNode.getImage()) ;   {if (true) return jjtn000 ;}
26665     } catch (Throwable jjte000) {
26666           if (jjtc000) {
26667             jjtree.clearNodeScope(jjtn000);
26668             jjtc000 = false;
26669           } else {
26670             jjtree.popNode();
26671           }
26672           if (jjte000 instanceof RuntimeException) {
26673             {if (true) throw (RuntimeException)jjte000;}
26674           }
26675           if (jjte000 instanceof ParseException) {
26676             {if (true) throw (ParseException)jjte000;}
26677           }
26678           {if (true) throw (Error)jjte000;}
26679     } finally {
26680           if (jjtc000) {
26681             jjtree.closeNodeScope(jjtn000, true);
26682           }
26683     }
26684     throw new Error("Missing return statement in function");
26685   }
26686 
26687   final public ASTAttribute Attribute() throws ParseException {
26688  /*@bgen(jjtree) Attribute */
26689  ASTAttribute jjtn000 = new ASTAttribute(this, JJTATTRIBUTE);
26690  boolean jjtc000 = true;
26691  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26692     try {
26693       simpleNode = ID();
26694         jjtree.closeNodeScope(jjtn000, true);
26695         jjtc000 = false;
26696         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
26697     } catch (Throwable jjte000) {
26698         if (jjtc000) {
26699           jjtree.clearNodeScope(jjtn000);
26700           jjtc000 = false;
26701         } else {
26702           jjtree.popNode();
26703         }
26704         if (jjte000 instanceof RuntimeException) {
26705           {if (true) throw (RuntimeException)jjte000;}
26706         }
26707         if (jjte000 instanceof ParseException) {
26708           {if (true) throw (ParseException)jjte000;}
26709         }
26710         {if (true) throw (Error)jjte000;}
26711     } finally {
26712         if (jjtc000) {
26713           jjtree.closeNodeScope(jjtn000, true);
26714         }
26715     }
26716     throw new Error("Missing return statement in function");
26717   }
26718 
26719 /*
26720  This was quick cut from PRAGMA
26721 */
26722   final public ASTPragmaClause PragmaClause() throws ParseException {
26723  /*@bgen(jjtree) PragmaClause */
26724   ASTPragmaClause jjtn000 = new ASTPragmaClause(this, JJTPRAGMACLAUSE);
26725   boolean jjtc000 = true;
26726   jjtree.openNodeScope(jjtn000);
26727     try {
26728       jj_consume_token(PRAGMA);
26729       switch (jj_nt.kind) {
26730       case SERIALLY_REUSABLE:
26731         jj_consume_token(SERIALLY_REUSABLE);
26732         break;
26733       case AUTONOMOUS_TRANSACTION:
26734         jj_consume_token(AUTONOMOUS_TRANSACTION);
26735         break;
26736       case RESTRICT_REFERENCES:
26737         jj_consume_token(RESTRICT_REFERENCES);
26738         jj_consume_token(5);
26739         ID();
26740         label_94:
26741         while (true) {
26742           jj_consume_token(6);
26743           switch (jj_nt.kind) {
26744           case REPLACE:
26745           case DEFINER:
26746           case CURRENT_USER:
26747           case SERIALLY_REUSABLE:
26748           case RESTRICT_REFERENCES:
26749           case EXCEPTION_INIT:
26750           case AUTONOMOUS_TRANSACTION:
26751           case LANGUAGE:
26752           case INLINE:
26753           case ADD:
26754           case AGGREGATE:
26755           case ALL:
26756           case ALTER:
26757           case AND:
26758           case ANY:
26759           case ARRAY:
26760           case AS:
26761           case ASC:
26762           case AT:
26763           case ATTRIBUTE:
26764           case AUTHID:
26765           case AVG:
26766           case BETWEEN:
26767           case BINARY_INTEGER:
26768           case BODY:
26769           case BOOLEAN:
26770           case BULK:
26771           case BY:
26772           case BYTE:
26773           case CASCADE:
26774           case CASE:
26775           case CHAR:
26776           case CHAR_BASE:
26777           case CHECK:
26778           case CLOSE:
26779           case CLUSTER:
26780           case COALESCE:
26781           case COLLECT:
26782           case COLUMN:
26783           case COMMENT:
26784           case COMMIT:
26785           case COMPRESS:
26786           case CONNECT:
26787           case CONSTANT:
26788           case CONSTRUCTOR:
26789           case CONTINUE:
26790           case CONVERT:
26791           case CREATE:
26792           case CURRENT:
26793           case CURRVAL:
26794           case CURSOR:
26795           case DATA:
26796           case DATE:
26797           case DAY:
26798           case DECLARE:
26799           case DECIMAL:
26800           case _DEFAULT:
26801           case DELETE:
26802           case DESC:
26803           case DISABLE:
26804           case DISTINCT:
26805           case DO:
26806           case DROP:
26807           case EDITIONABLE:
26808           case ELEMENT:
26809           case ELSE:
26810           case ELSIF:
26811           case ENABLE:
26812           case ESCAPE:
26813           case EXCEPT:
26814           case EXCEPTION:
26815           case EXCEPTIONS:
26816           case EXCLUSIVE:
26817           case EXECUTE:
26818           case EXISTS:
26819           case EXIT:
26820           case EXTERNAL:
26821           case EXTENDS:
26822           case EXTRACT:
26823           case FALSE:
26824           case FETCH:
26825           case FINAL:
26826           case FLOAT:
26827           case FOR:
26828           case FORALL:
26829           case FORCE:
26830           case FROM:
26831           case FUNCTION:
26832           case GLOBAL:
26833           case GOTO:
26834           case GROUP:
26835           case HASH:
26836           case HAVING:
26837           case HEAP:
26838           case HOUR:
26839           case IF:
26840           case IMMEDIATE:
26841           case IN:
26842           case INDEX:
26843           case INDICES:
26844           case INDEXTYPE:
26845           case INDICATOR:
26846           case INSERT:
26847           case INSTANTIABLE:
26848           case INTEGER:
26849           case INTERFACE:
26850           case INTERSECT:
26851           case INTERVAL:
26852           case INTO:
26853           case INVALIDATE:
26854           case IS:
26855           case ISOLATION:
26856           case JAVA:
26857           case LEVEL:
26858           case LIKE:
26859           case LIMIT:
26860           case LIMITED:
26861           case LOCK:
26862           case LONG:
26863           case LOOP:
26864           case MAP:
26865           case MAX:
26866           case MEMBER:
26867           case MERGE:
26868           case MIN:
26869           case MINUS:
26870           case MINUTE:
26871           case MLSLABEL:
26872           case MODIFY:
26873           case MOD:
26874           case MODE:
26875           case MONTH:
26876           case NATURAL:
26877           case NATURALN:
26878           case NEW:
26879           case NEXTVAL:
26880           case NO:
26881           case NOCOPY:
26882           case NONEDITIONABLE:
26883           case NOT:
26884           case NOWAIT:
26885           case NULL:
26886           case NULLIF:
26887           case NUMBER:
26888           case BFILE_BASE:
26889           case BLOB_BASE:
26890           case CLOB_BASE:
26891           case DATE_BASE:
26892           case NUMBER_BASE:
26893           case OBJECT:
26894           case OCIROWID:
26895           case OF:
26896           case OID:
26897           case ON:
26898           case OPAQUE:
26899           case OPEN:
26900           case OPERATOR:
26901           case OPTION:
26902           case OR:
26903           case ORDER:
26904           case ORGANIZATION:
26905           case OTHERS:
26906           case OUT:
26907           case OVERRIDING:
26908           case PACKAGE:
26909           case PARTITION:
26910           case PCTFREE:
26911           case PLS_INTEGER:
26912           case POSITIVE:
26913           case POSITIVEN:
26914           case PRESERVE:
26915           case PRIOR:
26916           case PROMPT:
26917           case PRIVATE:
26918           case PROCEDURE:
26919           case PUBLIC:
26920           case RAISE:
26921           case RANGE:
26922           case RAW:
26923           case REAL:
26924           case RECORD:
26925           case REF:
26926           case RELEASE:
26927           case RELIES_ON:
26928           case RENAME:
26929           case RESULT:
26930           case RETURN:
26931           case RETURNING:
26932           case REVERSE:
26933           case ROLLBACK:
26934           case ROW:
26935           case ROWS:
26936           case ROWID:
26937           case ROWNUM:
26938           case ROWTYPE:
26939           case SAVE:
26940           case SAVEPOINT:
26941           case SECOND:
26942           case SELECT:
26943           case SELF:
26944           case SEPARATE:
26945           case SET:
26946           case SHARE:
26947           case SMALLINT:
26948           case SPACE:
26949           case SQL:
26950           case SQLCODE:
26951           case SQLERRM:
26952           case START:
26953           case STATIC:
26954           case STDDEV:
26955           case SUBTYPE:
26956           case SUBSTITUTABLE:
26957           case SUCCESSFUL:
26958           case SUM:
26959           case SYNONYM:
26960           case SYSDATE:
26961           case SYS_REFCURSOR:
26962           case TABLE:
26963           case TEMPORARY:
26964           case THEN:
26965           case TIME:
26966           case TIMESTAMP:
26967           case TIMEZONE_REGION:
26968           case TIMEZONE_ABBR:
26969           case TIMEZONE_MINUTE:
26970           case TIMEZONE_HOUR:
26971           case TO:
26972           case TRANSACTION:
26973           case TRIGGER:
26974           case TRUE:
26975           case TYPE:
26976           case UI:
26977           case UNDER:
26978           case USING:
26979           case WHILE:
26980           case YES:
26981           case SHOW:
26982           case A:
26983           case UPDATE:
26984           case VARCHAR:
26985           case VARCHAR2:
26986           case DOUBLE:
26987           case DEC:
26988           case PRECISION:
26989           case INT:
26990           case NUMERIC:
26991           case SIGNTYPE:
26992           case NCHAR:
26993           case NVARCHAR2:
26994           case STRING:
26995           case UROWID:
26996           case VARRAY:
26997           case VARYING:
26998           case BFILE:
26999           case BLOB:
27000           case CLOB:
27001           case NCLOB:
27002           case YEAR:
27003           case LOCAL:
27004           case WITH:
27005           case ZONE:
27006           case CHARACTER:
27007           case AFTER:
27008           case BEFORE:
27009           case OLD:
27010           case PARENT:
27011           case ANALYZE:
27012           case ASSOCIATE:
27013           case AUDIT:
27014           case COMPOUND:
27015           case DATABASE:
27016           case CALL:
27017           case DDL:
27018           case DISASSOCIATE:
27019           case EACH:
27020           case FOLLOWS:
27021           case LOGOFF:
27022           case LOGON:
27023           case NESTED:
27024           case NOAUDIT:
27025           case SCHEMA:
27026           case SERVERERROR:
27027           case SHUTDOWN:
27028           case STARTUP:
27029           case STATEMENT:
27030           case STATISTICS:
27031           case SUSPEND:
27032           case TRUNCATE:
27033           case WRAPPED:
27034           case LIBRARY:
27035           case NAME:
27036           case STRUCT:
27037           case CONTEXT:
27038           case PARAMETERS:
27039           case LENGTH:
27040           case TDO:
27041           case MAXLEN:
27042           case CHARSETID:
27043           case CHARSETFORM:
27044           case ACCEPT:
27045           case ACCESSIBLE:
27046           case COPY:
27047           case DEFINE:
27048           case DISCONNECT:
27049           case HOST:
27050           case PRINT:
27051           case QUIT:
27052           case REMARK:
27053           case UNDEFINE:
27054           case VARIABLE:
27055           case WHENEVER:
27056           case ATTACH:
27057           case CAST:
27058           case TREAT:
27059           case TRIM:
27060           case LEFT:
27061           case RIGHT:
27062           case BOTH:
27063           case EMPTY:
27064           case MULTISET:
27065           case SUBMULTISET:
27066           case LEADING:
27067           case TRAILING:
27068           case CHAR_CS:
27069           case NCHAR_CS:
27070           case DBTIMEZONE:
27071           case SESSIONTIMEZONE:
27072           case AUTHENTICATED:
27073           case LINK:
27074           case SHARED:
27075           case DIRECTORY:
27076           case USER:
27077           case IDENTIFIER:
27078           case QUOTED_LITERAL:
27079           case SQLDATA_CLASS:
27080           case CUSTOMDATUM_CLASS:
27081           case ORADATA_CLASS:
27082           case JAVA_INTERFACE_CLASS:
27083             ID();
27084             break;
27085           case STRING_LITERAL:
27086             StringLiteral();
27087             break;
27088           default:
27089             jj_la1[401] = jj_gen;
27090             jj_consume_token(-1);
27091             throw new ParseException();
27092           }
27093           switch (jj_nt.kind) {
27094           case 6:
27095             ;
27096             break;
27097           default:
27098             jj_la1[402] = jj_gen;
27099             break label_94;
27100           }
27101         }
27102         jj_consume_token(7);
27103         break;
27104       case EXCEPTION_INIT:
27105         jj_consume_token(EXCEPTION_INIT);
27106         jj_consume_token(5);
27107         jj_consume_token(IDENTIFIER);
27108         jj_consume_token(6);
27109         switch (jj_nt.kind) {
27110         case 16:
27111         case 17:
27112           switch (jj_nt.kind) {
27113           case 16:
27114             jj_consume_token(16);
27115             break;
27116           case 17:
27117             jj_consume_token(17);
27118             break;
27119           default:
27120             jj_la1[403] = jj_gen;
27121             jj_consume_token(-1);
27122             throw new ParseException();
27123           }
27124           break;
27125         default:
27126           jj_la1[404] = jj_gen;
27127           ;
27128         }
27129         NumericLiteral();
27130         jj_consume_token(7);
27131         break;
27132       case INTERFACE:
27133         jj_consume_token(INTERFACE);
27134         jj_consume_token(5);
27135         jj_consume_token(IDENTIFIER);
27136         jj_consume_token(6);
27137         jj_consume_token(IDENTIFIER);
27138         jj_consume_token(6);
27139         NumericLiteral();
27140         jj_consume_token(7);
27141         break;
27142       default:
27143         jj_la1[405] = jj_gen;
27144         jj_consume_token(-1);
27145         throw new ParseException();
27146       }
27147         jjtree.closeNodeScope(jjtn000, true);
27148         jjtc000 = false;
27149         {if (true) return jjtn000 ;}
27150     } catch (Throwable jjte000) {
27151           if (jjtc000) {
27152             jjtree.clearNodeScope(jjtn000);
27153             jjtc000 = false;
27154           } else {
27155             jjtree.popNode();
27156           }
27157           if (jjte000 instanceof RuntimeException) {
27158             {if (true) throw (RuntimeException)jjte000;}
27159           }
27160           if (jjte000 instanceof ParseException) {
27161             {if (true) throw (ParseException)jjte000;}
27162           }
27163           {if (true) throw (Error)jjte000;}
27164     } finally {
27165           if (jjtc000) {
27166             jjtree.closeNodeScope(jjtn000, true);
27167           }
27168     }
27169     throw new Error("Missing return statement in function");
27170   }
27171 
27172 /** 
27173  * Trigger
27174  * Triggers are always outside of a package.
27175  *
27176  *  2006-05-17 - Matthias Hendler - added 
27177  */
27178 
27179 /*
27180   11g Trigger Syntax 
27181 
27182  create_trigger : 
27183  CREATE [OR REPLACE] TRIGGER [schema.]trigger 
27184 ( simple_dml_trigger | compound_dml_trigger | non_dml_trigger )
27185 [ FOLLOWS ( [schema.]trigger) ( , [schema.]trigger)*  ]
27186 [ ENABLE  | DISABLE ]
27187 ( WHEN ( trigger_condition ) 
27188 trigger_body
27189 
27190 
27191 simple_dml_trigger :
27192 (BEFORE |AFTER | INSTEAD OF)
27193 dml_event_clause 
27194 [ referencing_clause ]
27195 [ FOR EACH ROW ]
27196 
27197 
27198 
27199 compound_dml_trigger :
27200 FOR dml_event_clause 
27201 [ referencing_clause ]
27202 
27203 
27204 non_dml_trigger :
27205 (BEFORE> |<AFTER> ) 
27206 (DDLEvent | database_event) ( OR (DDLEvent | database_event))*
27207 ON
27208 (DATABASE | [schema.]SCHEMA
27209 
27210 
27211 
27212 trigger_body :
27213 (plsql_block | compound_trigger_block | CALL routine_clause)
27214 
27215 
27216 
27217 dml_event_clause:
27218 ( DELETE | INSERT | UPDATE [ OF column (, column ) ] )
27219 ON ( (schema.table | NESTED TABLE nested_table_column OF [schema.]view )
27220 
27221 referencing_clause:
27222 REFERENCING 
27223 (OLD AS old_alias | NEW AS new_alias | PARENT AS parent_alias )*  
27224 
27225 
27226 compound_trigger_block :
27227 COMPOUND TRIGGER 
27228 declare_section 
27229 (timing_point_section)+  
27230 END [trigger_name] ;
27231 
27232 timing_point_section:
27233 (
27234 BEFORE STATEMENT IS tps_body END BEFORE STATEMENT 
27235 |BEFORE EACH ROW IS tps_body END BEFORE EACH ROW 
27236 |AFTER STATEMENT IS tps_body END AFTER STATEMENT 
27237 |AFTER EACH ROW IS tps_body END AFTER EACH ROW 
27238 )
27239 
27240 
27241 tps_body:
27242 (statement)+
27243 (EXCEPTION exception_handler )*
27244 
27245 */
27246   final public ASTTriggerUnit TriggerUnit() throws ParseException {
27247  /*@bgen(jjtree) TriggerUnit */
27248  ASTTriggerUnit jjtn000 = new ASTTriggerUnit(this, JJTTRIGGERUNIT);
27249  boolean jjtc000 = true;
27250  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
27251     try {
27252       switch (jj_nt.kind) {
27253       case CREATE:
27254         jj_consume_token(CREATE);
27255         switch (jj_nt.kind) {
27256         case OR:
27257           jj_consume_token(OR);
27258           jj_consume_token(REPLACE);
27259           break;
27260         default:
27261           jj_la1[406] = jj_gen;
27262           ;
27263         }
27264         switch (jj_nt.kind) {
27265         case EDITIONABLE:
27266         case NONEDITIONABLE:
27267           switch (jj_nt.kind) {
27268           case EDITIONABLE:
27269             jj_consume_token(EDITIONABLE);
27270             break;
27271           case NONEDITIONABLE:
27272             jj_consume_token(NONEDITIONABLE);
27273             break;
27274           default:
27275             jj_la1[407] = jj_gen;
27276             jj_consume_token(-1);
27277             throw new ParseException();
27278           }
27279           break;
27280         default:
27281           jj_la1[408] = jj_gen;
27282           ;
27283         }
27284         break;
27285       default:
27286         jj_la1[409] = jj_gen;
27287         ;
27288       }
27289       jj_consume_token(TRIGGER);
27290       simpleNode = ObjectNameDeclaration();
27291       switch (jj_nt.kind) {
27292       case BEFORE:
27293         jj_consume_token(BEFORE);
27294         break;
27295       case AFTER:
27296         jj_consume_token(AFTER);
27297         break;
27298       case INSTEADOF:
27299         jj_consume_token(INSTEADOF);
27300         break;
27301       case FOR:
27302         jj_consume_token(FOR);
27303         break;
27304       default:
27305         jj_la1[410] = jj_gen;
27306         jj_consume_token(-1);
27307         throw new ParseException();
27308       }
27309       switch (jj_nt.kind) {
27310       case DELETE:
27311       case INSERT:
27312       case UPDATE:
27313         switch (jj_nt.kind) {
27314         case DELETE:
27315           jj_consume_token(DELETE);
27316           break;
27317         case INSERT:
27318           jj_consume_token(INSERT);
27319           break;
27320         case UPDATE:
27321           jj_consume_token(UPDATE);
27322           break;
27323         default:
27324           jj_la1[411] = jj_gen;
27325           jj_consume_token(-1);
27326           throw new ParseException();
27327         }
27328         if (jj_2_73(6)) {
27329           jj_consume_token(OF);
27330           ID();
27331           label_95:
27332           while (true) {
27333             switch (jj_nt.kind) {
27334             case 6:
27335               ;
27336               break;
27337             default:
27338               jj_la1[412] = jj_gen;
27339               break label_95;
27340             }
27341             jj_consume_token(6);
27342             ID();
27343           }
27344         } else {
27345           ;
27346         }
27347         break;
27348       case ALTER:
27349       case COMMENT:
27350       case CREATE:
27351       case DROP:
27352       case GRANT:
27353       case RENAME:
27354       case REVOKE:
27355       case ANALYZE:
27356       case ASSOCIATE:
27357       case AUDIT:
27358       case DDL:
27359       case DISASSOCIATE:
27360       case LOGOFF:
27361       case LOGON:
27362       case NOAUDIT:
27363       case SERVERERROR:
27364       case SHUTDOWN:
27365       case STARTUP:
27366       case SUSPEND:
27367       case TRUNCATE:
27368         NonDMLEvent();
27369         break;
27370       default:
27371         jj_la1[413] = jj_gen;
27372         jj_consume_token(-1);
27373         throw new ParseException();
27374       }
27375       label_96:
27376       while (true) {
27377         switch (jj_nt.kind) {
27378         case OR:
27379           ;
27380           break;
27381         default:
27382           jj_la1[414] = jj_gen;
27383           break label_96;
27384         }
27385         jj_consume_token(OR);
27386         switch (jj_nt.kind) {
27387         case DELETE:
27388         case INSERT:
27389         case UPDATE:
27390           switch (jj_nt.kind) {
27391           case DELETE:
27392             jj_consume_token(DELETE);
27393             break;
27394           case INSERT:
27395             jj_consume_token(INSERT);
27396             break;
27397           case UPDATE:
27398             jj_consume_token(UPDATE);
27399             break;
27400           default:
27401             jj_la1[415] = jj_gen;
27402             jj_consume_token(-1);
27403             throw new ParseException();
27404           }
27405           if (jj_2_74(6)) {
27406             jj_consume_token(OF);
27407             ID();
27408             label_97:
27409             while (true) {
27410               switch (jj_nt.kind) {
27411               case 6:
27412                 ;
27413                 break;
27414               default:
27415                 jj_la1[416] = jj_gen;
27416                 break label_97;
27417               }
27418               jj_consume_token(6);
27419               ID();
27420             }
27421           } else {
27422             ;
27423           }
27424           break;
27425         case ALTER:
27426         case COMMENT:
27427         case CREATE:
27428         case DROP:
27429         case GRANT:
27430         case RENAME:
27431         case REVOKE:
27432         case ANALYZE:
27433         case ASSOCIATE:
27434         case AUDIT:
27435         case DDL:
27436         case DISASSOCIATE:
27437         case LOGOFF:
27438         case LOGON:
27439         case NOAUDIT:
27440         case SERVERERROR:
27441         case SHUTDOWN:
27442         case STARTUP:
27443         case SUSPEND:
27444         case TRUNCATE:
27445           NonDMLEvent();
27446           break;
27447         default:
27448           jj_la1[417] = jj_gen;
27449           jj_consume_token(-1);
27450           throw new ParseException();
27451         }
27452       }
27453       jj_consume_token(ON);
27454       switch (jj_nt.kind) {
27455       case DATABASE:
27456         jj_consume_token(DATABASE);
27457         break;
27458       default:
27459         jj_la1[418] = jj_gen;
27460         if (jj_2_77(2)) {
27461           jj_consume_token(NESTED);
27462           jj_consume_token(TABLE);
27463           ID();
27464           jj_consume_token(OF);
27465           if (jj_2_75(2)) {
27466             ID();
27467             jj_consume_token(3);
27468           } else {
27469             ;
27470           }
27471           ID();
27472         } else {
27473           switch (jj_nt.kind) {
27474           case REPLACE:
27475           case DEFINER:
27476           case CURRENT_USER:
27477           case SERIALLY_REUSABLE:
27478           case RESTRICT_REFERENCES:
27479           case EXCEPTION_INIT:
27480           case AUTONOMOUS_TRANSACTION:
27481           case LANGUAGE:
27482           case INLINE:
27483           case ADD:
27484           case AGGREGATE:
27485           case ALL:
27486           case ALTER:
27487           case AND:
27488           case ANY:
27489           case ARRAY:
27490           case AS:
27491           case ASC:
27492           case AT:
27493           case ATTRIBUTE:
27494           case AUTHID:
27495           case AVG:
27496           case BETWEEN:
27497           case BINARY_INTEGER:
27498           case BODY:
27499           case BOOLEAN:
27500           case BULK:
27501           case BY:
27502           case BYTE:
27503           case CASCADE:
27504           case CASE:
27505           case CHAR:
27506           case CHAR_BASE:
27507           case CHECK:
27508           case CLOSE:
27509           case CLUSTER:
27510           case COALESCE:
27511           case COLLECT:
27512           case COLUMN:
27513           case COMMENT:
27514           case COMMIT:
27515           case COMPRESS:
27516           case CONNECT:
27517           case CONSTANT:
27518           case CONSTRUCTOR:
27519           case CONTINUE:
27520           case CONVERT:
27521           case CREATE:
27522           case CURRENT:
27523           case CURRVAL:
27524           case CURSOR:
27525           case DATA:
27526           case DATE:
27527           case DAY:
27528           case DECLARE:
27529           case DECIMAL:
27530           case _DEFAULT:
27531           case DELETE:
27532           case DESC:
27533           case DISABLE:
27534           case DISTINCT:
27535           case DO:
27536           case DROP:
27537           case EDITIONABLE:
27538           case ELEMENT:
27539           case ELSE:
27540           case ELSIF:
27541           case ENABLE:
27542           case ESCAPE:
27543           case EXCEPT:
27544           case EXCEPTION:
27545           case EXCEPTIONS:
27546           case EXCLUSIVE:
27547           case EXECUTE:
27548           case EXISTS:
27549           case EXIT:
27550           case EXTERNAL:
27551           case EXTENDS:
27552           case EXTRACT:
27553           case FALSE:
27554           case FETCH:
27555           case FINAL:
27556           case FLOAT:
27557           case FOR:
27558           case FORALL:
27559           case FORCE:
27560           case FROM:
27561           case FUNCTION:
27562           case GLOBAL:
27563           case GOTO:
27564           case GROUP:
27565           case HASH:
27566           case HAVING:
27567           case HEAP:
27568           case HOUR:
27569           case IF:
27570           case IMMEDIATE:
27571           case IN:
27572           case INDEX:
27573           case INDICES:
27574           case INDEXTYPE:
27575           case INDICATOR:
27576           case INSERT:
27577           case INSTANTIABLE:
27578           case INTEGER:
27579           case INTERFACE:
27580           case INTERSECT:
27581           case INTERVAL:
27582           case INTO:
27583           case INVALIDATE:
27584           case IS:
27585           case ISOLATION:
27586           case JAVA:
27587           case LEVEL:
27588           case LIKE:
27589           case LIMIT:
27590           case LIMITED:
27591           case LOCK:
27592           case LONG:
27593           case LOOP:
27594           case MAP:
27595           case MAX:
27596           case MEMBER:
27597           case MERGE:
27598           case MIN:
27599           case MINUS:
27600           case MINUTE:
27601           case MLSLABEL:
27602           case MODIFY:
27603           case MOD:
27604           case MODE:
27605           case MONTH:
27606           case NATURAL:
27607           case NATURALN:
27608           case NEW:
27609           case NEXTVAL:
27610           case NO:
27611           case NOCOPY:
27612           case NONEDITIONABLE:
27613           case NOT:
27614           case NOWAIT:
27615           case NULL:
27616           case NULLIF:
27617           case NUMBER:
27618           case BFILE_BASE:
27619           case BLOB_BASE:
27620           case CLOB_BASE:
27621           case DATE_BASE:
27622           case NUMBER_BASE:
27623           case OBJECT:
27624           case OCIROWID:
27625           case OF:
27626           case OID:
27627           case ON:
27628           case OPAQUE:
27629           case OPEN:
27630           case OPERATOR:
27631           case OPTION:
27632           case OR:
27633           case ORDER:
27634           case ORGANIZATION:
27635           case OTHERS:
27636           case OUT:
27637           case OVERRIDING:
27638           case PACKAGE:
27639           case PARTITION:
27640           case PCTFREE:
27641           case PLS_INTEGER:
27642           case POSITIVE:
27643           case POSITIVEN:
27644           case PRESERVE:
27645           case PRIOR:
27646           case PROMPT:
27647           case PRIVATE:
27648           case PROCEDURE:
27649           case PUBLIC:
27650           case RAISE:
27651           case RANGE:
27652           case RAW:
27653           case REAL:
27654           case RECORD:
27655           case REF:
27656           case RELEASE:
27657           case RELIES_ON:
27658           case RENAME:
27659           case RESULT:
27660           case RETURN:
27661           case RETURNING:
27662           case REVERSE:
27663           case ROLLBACK:
27664           case ROW:
27665           case ROWS:
27666           case ROWID:
27667           case ROWNUM:
27668           case ROWTYPE:
27669           case SAVE:
27670           case SAVEPOINT:
27671           case SECOND:
27672           case SELECT:
27673           case SELF:
27674           case SEPARATE:
27675           case SET:
27676           case SHARE:
27677           case SMALLINT:
27678           case SPACE:
27679           case SQL:
27680           case SQLCODE:
27681           case SQLERRM:
27682           case START:
27683           case STATIC:
27684           case STDDEV:
27685           case SUBTYPE:
27686           case SUBSTITUTABLE:
27687           case SUCCESSFUL:
27688           case SUM:
27689           case SYNONYM:
27690           case SYSDATE:
27691           case SYS_REFCURSOR:
27692           case TABLE:
27693           case TEMPORARY:
27694           case THEN:
27695           case TIME:
27696           case TIMESTAMP:
27697           case TIMEZONE_REGION:
27698           case TIMEZONE_ABBR:
27699           case TIMEZONE_MINUTE:
27700           case TIMEZONE_HOUR:
27701           case TO:
27702           case TRANSACTION:
27703           case TRIGGER:
27704           case TRUE:
27705           case TYPE:
27706           case UI:
27707           case UNDER:
27708           case USING:
27709           case WHILE:
27710           case YES:
27711           case SHOW:
27712           case A:
27713           case UPDATE:
27714           case VARCHAR:
27715           case VARCHAR2:
27716           case DOUBLE:
27717           case DEC:
27718           case PRECISION:
27719           case INT:
27720           case NUMERIC:
27721           case SIGNTYPE:
27722           case NCHAR:
27723           case NVARCHAR2:
27724           case STRING:
27725           case UROWID:
27726           case VARRAY:
27727           case VARYING:
27728           case BFILE:
27729           case BLOB:
27730           case CLOB:
27731           case NCLOB:
27732           case YEAR:
27733           case LOCAL:
27734           case WITH:
27735           case ZONE:
27736           case CHARACTER:
27737           case AFTER:
27738           case BEFORE:
27739           case OLD:
27740           case PARENT:
27741           case ANALYZE:
27742           case ASSOCIATE:
27743           case AUDIT:
27744           case COMPOUND:
27745           case DATABASE:
27746           case CALL:
27747           case DDL:
27748           case DISASSOCIATE:
27749           case EACH:
27750           case FOLLOWS:
27751           case LOGOFF:
27752           case LOGON:
27753           case NESTED:
27754           case NOAUDIT:
27755           case SCHEMA:
27756           case SERVERERROR:
27757           case SHUTDOWN:
27758           case STARTUP:
27759           case STATEMENT:
27760           case STATISTICS:
27761           case SUSPEND:
27762           case TRUNCATE:
27763           case WRAPPED:
27764           case LIBRARY:
27765           case NAME:
27766           case STRUCT:
27767           case CONTEXT:
27768           case PARAMETERS:
27769           case LENGTH:
27770           case TDO:
27771           case MAXLEN:
27772           case CHARSETID:
27773           case CHARSETFORM:
27774           case ACCEPT:
27775           case ACCESSIBLE:
27776           case COPY:
27777           case DEFINE:
27778           case DISCONNECT:
27779           case HOST:
27780           case PRINT:
27781           case QUIT:
27782           case REMARK:
27783           case UNDEFINE:
27784           case VARIABLE:
27785           case WHENEVER:
27786           case ATTACH:
27787           case CAST:
27788           case TREAT:
27789           case TRIM:
27790           case LEFT:
27791           case RIGHT:
27792           case BOTH:
27793           case EMPTY:
27794           case MULTISET:
27795           case SUBMULTISET:
27796           case LEADING:
27797           case TRAILING:
27798           case CHAR_CS:
27799           case NCHAR_CS:
27800           case DBTIMEZONE:
27801           case SESSIONTIMEZONE:
27802           case AUTHENTICATED:
27803           case LINK:
27804           case SHARED:
27805           case DIRECTORY:
27806           case USER:
27807           case IDENTIFIER:
27808           case QUOTED_LITERAL:
27809           case SQLDATA_CLASS:
27810           case CUSTOMDATUM_CLASS:
27811           case ORADATA_CLASS:
27812           case JAVA_INTERFACE_CLASS:
27813             if (jj_2_76(2)) {
27814               ID();
27815               jj_consume_token(3);
27816             } else {
27817               ;
27818             }
27819             ID();
27820             break;
27821           default:
27822             jj_la1[419] = jj_gen;
27823             jj_consume_token(-1);
27824             throw new ParseException();
27825           }
27826         }
27827       }
27828       switch (jj_nt.kind) {
27829       case REFERENCING:
27830         jj_consume_token(REFERENCING);
27831         label_98:
27832         while (true) {
27833           switch (jj_nt.kind) {
27834           case NEW:
27835           case OLD:
27836           case PARENT:
27837             ;
27838             break;
27839           default:
27840             jj_la1[420] = jj_gen;
27841             break label_98;
27842           }
27843           switch (jj_nt.kind) {
27844           case OLD:
27845             jj_consume_token(OLD);
27846             break;
27847           case NEW:
27848             jj_consume_token(NEW);
27849             break;
27850           case PARENT:
27851             jj_consume_token(PARENT);
27852             break;
27853           default:
27854             jj_la1[421] = jj_gen;
27855             jj_consume_token(-1);
27856             throw new ParseException();
27857           }
27858           jj_consume_token(AS);
27859           ID();
27860         }
27861         break;
27862       default:
27863         jj_la1[422] = jj_gen;
27864         ;
27865       }
27866       switch (jj_nt.kind) {
27867       case FOREACHROW:
27868         jj_consume_token(FOREACHROW);
27869         break;
27870       default:
27871         jj_la1[423] = jj_gen;
27872         ;
27873       }
27874       switch (jj_nt.kind) {
27875       case REVERSE:
27876       case FORWARD:
27877       case CROSSEDITION:
27878         switch (jj_nt.kind) {
27879         case REVERSE:
27880         case FORWARD:
27881           switch (jj_nt.kind) {
27882           case FORWARD:
27883             jj_consume_token(FORWARD);
27884             break;
27885           case REVERSE:
27886             jj_consume_token(REVERSE);
27887             break;
27888           default:
27889             jj_la1[424] = jj_gen;
27890             jj_consume_token(-1);
27891             throw new ParseException();
27892           }
27893           break;
27894         default:
27895           jj_la1[425] = jj_gen;
27896           ;
27897         }
27898         jj_consume_token(CROSSEDITION);
27899         break;
27900       default:
27901         jj_la1[426] = jj_gen;
27902         ;
27903       }
27904       switch (jj_nt.kind) {
27905       case FOLLOWS:
27906       case PRECEDES:
27907         switch (jj_nt.kind) {
27908         case FOLLOWS:
27909           jj_consume_token(FOLLOWS);
27910           break;
27911         case PRECEDES:
27912           jj_consume_token(PRECEDES);
27913           break;
27914         default:
27915           jj_la1[427] = jj_gen;
27916           jj_consume_token(-1);
27917           throw new ParseException();
27918         }
27919         if (jj_2_78(2)) {
27920           ID();
27921           jj_consume_token(3);
27922         } else {
27923           ;
27924         }
27925         ID();
27926         label_99:
27927         while (true) {
27928           switch (jj_nt.kind) {
27929           case 6:
27930             ;
27931             break;
27932           default:
27933             jj_la1[428] = jj_gen;
27934             break label_99;
27935           }
27936           jj_consume_token(6);
27937           if (jj_2_79(2)) {
27938             ID();
27939             jj_consume_token(3);
27940           } else {
27941             ;
27942           }
27943           ID();
27944         }
27945         break;
27946       default:
27947         jj_la1[429] = jj_gen;
27948         ;
27949       }
27950       switch (jj_nt.kind) {
27951       case DISABLE:
27952       case ENABLE:
27953         switch (jj_nt.kind) {
27954         case ENABLE:
27955           jj_consume_token(ENABLE);
27956           break;
27957         case DISABLE:
27958           jj_consume_token(DISABLE);
27959           break;
27960         default:
27961           jj_la1[430] = jj_gen;
27962           jj_consume_token(-1);
27963           throw new ParseException();
27964         }
27965         break;
27966       default:
27967         jj_la1[431] = jj_gen;
27968         ;
27969       }
27970       switch (jj_nt.kind) {
27971       case WHEN:
27972         jj_consume_token(WHEN);
27973         jj_consume_token(5);
27974         ConditionalOrExpression();
27975         jj_consume_token(7);
27976         break;
27977       default:
27978         jj_la1[432] = jj_gen;
27979         ;
27980       }
27981       switch (jj_nt.kind) {
27982       case CALL:
27983         jj_consume_token(CALL);
27984         PrimaryExpression();
27985         jj_consume_token(4);
27986         break;
27987       case COMPOUND:
27988         CompoundTriggerBlock();
27989         break;
27990       case BEGIN:
27991       case DECLARE:
27992         Block();
27993         jj_consume_token(4);
27994         break;
27995       default:
27996         jj_la1[433] = jj_gen;
27997         jj_consume_token(-1);
27998         throw new ParseException();
27999       }
28000         jjtree.closeNodeScope(jjtn000, true);
28001         jjtc000 = false;
28002         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
28003     } catch (Throwable jjte000) {
28004           if (jjtc000) {
28005             jjtree.clearNodeScope(jjtn000);
28006             jjtc000 = false;
28007           } else {
28008             jjtree.popNode();
28009           }
28010           if (jjte000 instanceof RuntimeException) {
28011             {if (true) throw (RuntimeException)jjte000;}
28012           }
28013           if (jjte000 instanceof ParseException) {
28014             {if (true) throw (ParseException)jjte000;}
28015           }
28016           {if (true) throw (Error)jjte000;}
28017     } finally {
28018           if (jjtc000) {
28019             jjtree.closeNodeScope(jjtn000, true);
28020           }
28021     }
28022     throw new Error("Missing return statement in function");
28023   }
28024 
28025   final public ASTTriggerTimingPointSection TriggerTimingPointSection() throws ParseException {
28026  /*@bgen(jjtree) TriggerTimingPointSection */
28027  ASTTriggerTimingPointSection jjtn000 = new ASTTriggerTimingPointSection(this, JJTTRIGGERTIMINGPOINTSECTION);
28028  boolean jjtc000 = true;
28029  jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
28030     try {
28031       switch (jj_nt.kind) {
28032       case BEFORE:
28033         jj_consume_token(BEFORE);
28034         break;
28035       case AFTER:
28036         jj_consume_token(AFTER);
28037         break;
28038       case INSTEADOF:
28039         jj_consume_token(INSTEADOF);
28040         break;
28041       default:
28042         jj_la1[434] = jj_gen;
28043         jj_consume_token(-1);
28044         throw new ParseException();
28045       }
28046                                         sb.append(token.image) ;
28047       switch (jj_nt.kind) {
28048       case STATEMENT:
28049         jj_consume_token(STATEMENT);
28050         break;
28051       case EACH:
28052         jj_consume_token(EACH);
28053         jj_consume_token(ROW);
28054         break;
28055       default:
28056         jj_la1[435] = jj_gen;
28057         jj_consume_token(-1);
28058         throw new ParseException();
28059       }
28060                                      sb.append(" "); sb.append(token.image) ;
28061       jj_consume_token(IS);
28062       jj_consume_token(BEGIN);
28063       label_100:
28064       while (true) {
28065         Statement();
28066         switch (jj_nt.kind) {
28067         case 5:
28068         case 16:
28069         case 17:
28070         case 21:
28071         case REPLACE:
28072         case DEFINER:
28073         case CURRENT_USER:
28074         case LANGUAGE:
28075         case INLINE:
28076         case ADD:
28077         case AGGREGATE:
28078         case ARRAY:
28079         case AT:
28080         case ATTRIBUTE:
28081         case AUTHID:
28082         case BEGIN:
28083         case BODY:
28084         case BULK:
28085         case BYTE:
28086         case CASCADE:
28087         case CASE:
28088         case CLOSE:
28089         case COALESCE:
28090         case COLLECT:
28091         case COLUMN:
28092         case COMMENT:
28093         case COMMIT:
28094         case CONSTRUCTOR:
28095         case CONTINUE:
28096         case CONVERT:
28097         case CURRENT:
28098         case CURSOR:
28099         case DATA:
28100         case DATE:
28101         case DAY:
28102         case DECLARE:
28103         case DELETE:
28104         case DISABLE:
28105         case EDITIONABLE:
28106         case ELEMENT:
28107         case ENABLE:
28108         case ESCAPE:
28109         case EXCEPT:
28110         case EXCEPTIONS:
28111         case EXECUTE:
28112         case EXIT:
28113         case EXTERNAL:
28114         case EXTENDS:
28115         case EXTRACT:
28116         case FALSE:
28117         case FETCH:
28118         case FINAL:
28119         case FOR:
28120         case FORALL:
28121         case FORCE:
28122         case FUNCTION:
28123         case GLOBAL:
28124         case GOTO:
28125         case HASH:
28126         case HEAP:
28127         case HOUR:
28128         case IF:
28129         case IMMEDIATE:
28130         case INDICES:
28131         case INDEXTYPE:
28132         case INDICATOR:
28133         case INSERT:
28134         case INSTANTIABLE:
28135         case INTERVAL:
28136         case INVALIDATE:
28137         case ISOLATION:
28138         case JAVA:
28139         case LEVEL:
28140         case LIMIT:
28141         case LOCK:
28142         case LOOP:
28143         case MAP:
28144         case MAX:
28145         case MEMBER:
28146         case MERGE:
28147         case MIN:
28148         case MINUTE:
28149         case MLSLABEL:
28150         case MODIFY:
28151         case MOD:
28152         case MONTH:
28153         case NATURAL:
28154         case NEW:
28155         case NEW_DOT:
28156         case NO:
28157         case NONEDITIONABLE:
28158         case NOT:
28159         case NULL:
28160         case NULLIF:
28161         case OBJECT:
28162         case OID:
28163         case OPAQUE:
28164         case OPEN:
28165         case OPERATOR:
28166         case ORGANIZATION:
28167         case OTHERS:
28168         case OVERRIDING:
28169         case PACKAGE:
28170         case PARTITION:
28171         case PIPE:
28172         case PRAGMA:
28173         case PRESERVE:
28174         case PRIVATE:
28175         case PROCEDURE:
28176         case RAISE:
28177         case RANGE:
28178         case RAW:
28179         case REAL:
28180         case RECORD:
28181         case REF:
28182         case RELEASE:
28183         case RELIES_ON:
28184         case RENAME:
28185         case RESULT:
28186         case RETURN:
28187         case RETURNING:
28188         case REVERSE:
28189         case ROLLBACK:
28190         case ROW:
28191         case ROWS:
28192         case ROWID:
28193         case ROWNUM:
28194         case SAVE:
28195         case SAVEPOINT:
28196         case SECOND:
28197         case SELECT:
28198         case SELF:
28199         case SET:
28200         case SPACE:
28201         case SQL:
28202         case SQLCODE:
28203         case SQLERRM:
28204         case STATIC:
28205         case SUBTYPE:
28206         case SUBSTITUTABLE:
28207         case SUCCESSFUL:
28208         case SYSDATE:
28209         case SYS_REFCURSOR:
28210         case TEMPORARY:
28211         case TIME:
28212         case TIMESTAMP:
28213         case TIMEZONE_REGION:
28214         case TIMEZONE_ABBR:
28215         case TIMEZONE_MINUTE:
28216         case TIMEZONE_HOUR:
28217         case TRANSACTION:
28218         case TRUE:
28219         case TYPE:
28220         case UNDER:
28221         case USING:
28222         case WHILE:
28223         case YES:
28224         case SHOW:
28225         case A:
28226         case UPDATE:
28227         case DOUBLE:
28228         case DEC:
28229         case PRECISION:
28230         case INT:
28231         case NUMERIC:
28232         case NCHAR:
28233         case NVARCHAR2:
28234         case STRING:
28235         case UROWID:
28236         case VARRAY:
28237         case VARYING:
28238         case BFILE:
28239         case BLOB:
28240         case CLOB:
28241         case NCLOB:
28242         case YEAR:
28243         case LOCAL:
28244         case WITH:
28245         case ZONE:
28246         case CHARACTER:
28247         case AFTER:
28248         case BEFORE:
28249         case OLD:
28250         case PARENT:
28251         case CC_IF:
28252         case CC_ERROR:
28253         case ANALYZE:
28254         case ASSOCIATE:
28255         case AUDIT:
28256         case COMPOUND:
28257         case DATABASE:
28258         case CALL:
28259         case DDL:
28260         case DISASSOCIATE:
28261         case EACH:
28262         case FOLLOWS:
28263         case LOGOFF:
28264         case LOGON:
28265         case NESTED:
28266         case NOAUDIT:
28267         case SCHEMA:
28268         case SERVERERROR:
28269         case SHUTDOWN:
28270         case STARTUP:
28271         case STATEMENT:
28272         case STATISTICS:
28273         case SUSPEND:
28274         case TRUNCATE:
28275         case WRAPPED:
28276         case LIBRARY:
28277         case NAME:
28278         case STRUCT:
28279         case CONTEXT:
28280         case PARAMETERS:
28281         case LENGTH:
28282         case TDO:
28283         case MAXLEN:
28284         case CHARSETID:
28285         case CHARSETFORM:
28286         case ACCEPT:
28287         case ACCESSIBLE:
28288         case COPY:
28289         case DEFINE:
28290         case DISCONNECT:
28291         case HOST:
28292         case PRINT:
28293         case QUIT:
28294         case REMARK:
28295         case UNDEFINE:
28296         case VARIABLE:
28297         case WHENEVER:
28298         case ATTACH:
28299         case CAST:
28300         case TREAT:
28301         case TRIM:
28302         case LEFT:
28303         case RIGHT:
28304         case BOTH:
28305         case EMPTY:
28306         case MULTISET:
28307         case SUBMULTISET:
28308         case LEADING:
28309         case TRAILING:
28310         case CHAR_CS:
28311         case NCHAR_CS:
28312         case DBTIMEZONE:
28313         case SESSIONTIMEZONE:
28314         case AUTHENTICATED:
28315         case LINK:
28316         case SHARED:
28317         case DIRECTORY:
28318         case USER:
28319         case IDENTIFIER:
28320         case UNSIGNED_NUMERIC_LITERAL:
28321         case CHARACTER_LITERAL:
28322         case STRING_LITERAL:
28323         case QUOTED_LITERAL:
28324           ;
28325           break;
28326         default:
28327           jj_la1[436] = jj_gen;
28328           break label_100;
28329         }
28330       }
28331       jj_consume_token(END);
28332       switch (jj_nt.kind) {
28333       case BEFORE:
28334         jj_consume_token(BEFORE);
28335         break;
28336       case AFTER:
28337         jj_consume_token(AFTER);
28338         break;
28339       case INSTEADOF:
28340         jj_consume_token(INSTEADOF);
28341         break;
28342       default:
28343         jj_la1[437] = jj_gen;
28344         jj_consume_token(-1);
28345         throw new ParseException();
28346       }
28347       switch (jj_nt.kind) {
28348       case STATEMENT:
28349         jj_consume_token(STATEMENT);
28350         break;
28351       case EACH:
28352         jj_consume_token(EACH);
28353         jj_consume_token(ROW);
28354         break;
28355       default:
28356         jj_la1[438] = jj_gen;
28357         jj_consume_token(-1);
28358         throw new ParseException();
28359       }
28360       jj_consume_token(4);
28361 
28362    jjtree.closeNodeScope(jjtn000, true);
28363    jjtc000 = false;
28364    jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
28365     } catch (Throwable jjte000) {
28366    if (jjtc000) {
28367      jjtree.clearNodeScope(jjtn000);
28368      jjtc000 = false;
28369    } else {
28370      jjtree.popNode();
28371    }
28372    if (jjte000 instanceof RuntimeException) {
28373      {if (true) throw (RuntimeException)jjte000;}
28374    }
28375    if (jjte000 instanceof ParseException) {
28376      {if (true) throw (ParseException)jjte000;}
28377    }
28378    {if (true) throw (Error)jjte000;}
28379     } finally {
28380    if (jjtc000) {
28381      jjtree.closeNodeScope(jjtn000, true);
28382    }
28383     }
28384     throw new Error("Missing return statement in function");
28385   }
28386 
28387   final public ASTCompoundTriggerBlock CompoundTriggerBlock() throws ParseException {
28388  /*@bgen(jjtree) CompoundTriggerBlock */
28389   ASTCompoundTriggerBlock jjtn000 = new ASTCompoundTriggerBlock(this, JJTCOMPOUNDTRIGGERBLOCK);
28390   boolean jjtc000 = true;
28391   jjtree.openNodeScope(jjtn000);
28392     try {
28393       jj_consume_token(COMPOUND);
28394       jj_consume_token(TRIGGER);
28395       label_101:
28396       while (true) {
28397         switch (jj_nt.kind) {
28398         case REPLACE:
28399         case DEFINER:
28400         case CURRENT_USER:
28401         case SERIALLY_REUSABLE:
28402         case RESTRICT_REFERENCES:
28403         case EXCEPTION_INIT:
28404         case AUTONOMOUS_TRANSACTION:
28405         case LANGUAGE:
28406         case INLINE:
28407         case ADD:
28408         case AGGREGATE:
28409         case ALL:
28410         case ALTER:
28411         case AND:
28412         case ANY:
28413         case ARRAY:
28414         case AS:
28415         case ASC:
28416         case AT:
28417         case ATTRIBUTE:
28418         case AUTHID:
28419         case AVG:
28420         case BETWEEN:
28421         case BINARY_INTEGER:
28422         case BODY:
28423         case BOOLEAN:
28424         case BULK:
28425         case BY:
28426         case BYTE:
28427         case CASCADE:
28428         case CASE:
28429         case CHAR:
28430         case CHAR_BASE:
28431         case CHECK:
28432         case CLOSE:
28433         case CLUSTER:
28434         case COALESCE:
28435         case COLLECT:
28436         case COLUMN:
28437         case COMMENT:
28438         case COMMIT:
28439         case COMPRESS:
28440         case CONNECT:
28441         case CONSTANT:
28442         case CONSTRUCTOR:
28443         case CONTINUE:
28444         case CONVERT:
28445         case CREATE:
28446         case CURRENT:
28447         case CURRVAL:
28448         case CURSOR:
28449         case DATA:
28450         case DATE:
28451         case DAY:
28452         case DECLARE:
28453         case DECIMAL:
28454         case _DEFAULT:
28455         case DELETE:
28456         case DESC:
28457         case DISABLE:
28458         case DISTINCT:
28459         case DO:
28460         case DROP:
28461         case EDITIONABLE:
28462         case ELEMENT:
28463         case ELSE:
28464         case ELSIF:
28465         case ENABLE:
28466         case ESCAPE:
28467         case EXCEPT:
28468         case EXCEPTION:
28469         case EXCEPTIONS:
28470         case EXCLUSIVE:
28471         case EXECUTE:
28472         case EXISTS:
28473         case EXIT:
28474         case EXTERNAL:
28475         case EXTENDS:
28476         case EXTRACT:
28477         case FALSE:
28478         case FETCH:
28479         case FINAL:
28480         case FLOAT:
28481         case FOR:
28482         case FORALL:
28483         case FORCE:
28484         case FROM:
28485         case FUNCTION:
28486         case GLOBAL:
28487         case GOTO:
28488         case GROUP:
28489         case HASH:
28490         case HAVING:
28491         case HEAP:
28492         case HOUR:
28493         case IF:
28494         case IMMEDIATE:
28495         case IN:
28496         case INDEX:
28497         case INDICES:
28498         case INDEXTYPE:
28499         case INDICATOR:
28500         case INSERT:
28501         case INSTANTIABLE:
28502         case INTEGER:
28503         case INTERFACE:
28504         case INTERSECT:
28505         case INTERVAL:
28506         case INTO:
28507         case INVALIDATE:
28508         case IS:
28509         case ISOLATION:
28510         case JAVA:
28511         case LEVEL:
28512         case LIKE:
28513         case LIMIT:
28514         case LIMITED:
28515         case LOCK:
28516         case LONG:
28517         case LOOP:
28518         case MAP:
28519         case MAX:
28520         case MEMBER:
28521         case MERGE:
28522         case MIN:
28523         case MINUS:
28524         case MINUTE:
28525         case MLSLABEL:
28526         case MODIFY:
28527         case MOD:
28528         case MODE:
28529         case MONTH:
28530         case NATURAL:
28531         case NATURALN:
28532         case NEW:
28533         case NEXTVAL:
28534         case NO:
28535         case NOCOPY:
28536         case NONEDITIONABLE:
28537         case NOT:
28538         case NOWAIT:
28539         case NULL:
28540         case NULLIF:
28541         case NUMBER:
28542         case BFILE_BASE:
28543         case BLOB_BASE:
28544         case CLOB_BASE:
28545         case DATE_BASE:
28546         case NUMBER_BASE:
28547         case OBJECT:
28548         case OCIROWID:
28549         case OF:
28550         case OID:
28551         case ON:
28552         case OPAQUE:
28553         case OPEN:
28554         case OPERATOR:
28555         case OPTION:
28556         case OR:
28557         case ORDER:
28558         case ORGANIZATION:
28559         case OTHERS:
28560         case OUT:
28561         case OVERRIDING:
28562         case PACKAGE:
28563         case PARTITION:
28564         case PCTFREE:
28565         case PLS_INTEGER:
28566         case POSITIVE:
28567         case POSITIVEN:
28568         case PRAGMA:
28569         case PRESERVE:
28570         case PRIOR:
28571         case PROMPT:
28572         case PRIVATE:
28573         case PROCEDURE:
28574         case PUBLIC:
28575         case RAISE:
28576         case RANGE:
28577         case RAW:
28578         case REAL:
28579         case RECORD:
28580         case REF:
28581         case RELEASE:
28582         case RELIES_ON:
28583         case RENAME:
28584         case RESULT:
28585         case RETURN:
28586         case RETURNING:
28587         case REVERSE:
28588         case ROLLBACK:
28589         case ROW:
28590         case ROWS:
28591         case ROWID:
28592         case ROWNUM:
28593         case ROWTYPE:
28594         case SAVE:
28595         case SAVEPOINT:
28596         case SECOND:
28597         case SELECT:
28598         case SELF:
28599         case SEPARATE:
28600         case SET:
28601         case SHARE:
28602         case SMALLINT:
28603         case SPACE:
28604         case SQL:
28605         case SQLCODE:
28606         case SQLERRM:
28607         case START:
28608         case STATIC:
28609         case STDDEV:
28610         case SUBTYPE:
28611         case SUBSTITUTABLE:
28612         case SUCCESSFUL:
28613         case SUM:
28614         case SYNONYM:
28615         case SYSDATE:
28616         case SYS_REFCURSOR:
28617         case TABLE:
28618         case TEMPORARY:
28619         case THEN:
28620         case TIME:
28621         case TIMESTAMP:
28622         case TIMEZONE_REGION:
28623         case TIMEZONE_ABBR:
28624         case TIMEZONE_MINUTE:
28625         case TIMEZONE_HOUR:
28626         case TO:
28627         case TRANSACTION:
28628         case TRIGGER:
28629         case TRUE:
28630         case TYPE:
28631         case UI:
28632         case UNDER:
28633         case USING:
28634         case WHILE:
28635         case YES:
28636         case SHOW:
28637         case A:
28638         case UPDATE:
28639         case VARCHAR:
28640         case VARCHAR2:
28641         case DOUBLE:
28642         case DEC:
28643         case PRECISION:
28644         case INT:
28645         case NUMERIC:
28646         case SIGNTYPE:
28647         case NCHAR:
28648         case NVARCHAR2:
28649         case STRING:
28650         case UROWID:
28651         case VARRAY:
28652         case VARYING:
28653         case BFILE:
28654         case BLOB:
28655         case CLOB:
28656         case NCLOB:
28657         case YEAR:
28658         case LOCAL:
28659         case WITH:
28660         case ZONE:
28661         case CHARACTER:
28662         case AFTER:
28663         case BEFORE:
28664         case INSTEADOF:
28665         case OLD:
28666         case PARENT:
28667         case ANALYZE:
28668         case ASSOCIATE:
28669         case AUDIT:
28670         case COMPOUND:
28671         case DATABASE:
28672         case CALL:
28673         case DDL:
28674         case DISASSOCIATE:
28675         case EACH:
28676         case FOLLOWS:
28677         case LOGOFF:
28678         case LOGON:
28679         case NESTED:
28680         case NOAUDIT:
28681         case SCHEMA:
28682         case SERVERERROR:
28683         case SHUTDOWN:
28684         case STARTUP:
28685         case STATEMENT:
28686         case STATISTICS:
28687         case SUSPEND:
28688         case TRUNCATE:
28689         case WRAPPED:
28690         case LIBRARY:
28691         case NAME:
28692         case STRUCT:
28693         case CONTEXT:
28694         case PARAMETERS:
28695         case LENGTH:
28696         case TDO:
28697         case MAXLEN:
28698         case CHARSETID:
28699         case CHARSETFORM:
28700         case ACCEPT:
28701         case ACCESSIBLE:
28702         case COPY:
28703         case DEFINE:
28704         case DISCONNECT:
28705         case HOST:
28706         case PRINT:
28707         case QUIT:
28708         case REMARK:
28709         case UNDEFINE:
28710         case VARIABLE:
28711         case WHENEVER:
28712         case ATTACH:
28713         case CAST:
28714         case TREAT:
28715         case TRIM:
28716         case LEFT:
28717         case RIGHT:
28718         case BOTH:
28719         case EMPTY:
28720         case MULTISET:
28721         case SUBMULTISET:
28722         case LEADING:
28723         case TRAILING:
28724         case CHAR_CS:
28725         case NCHAR_CS:
28726         case DBTIMEZONE:
28727         case SESSIONTIMEZONE:
28728         case AUTHENTICATED:
28729         case LINK:
28730         case SHARED:
28731         case DIRECTORY:
28732         case USER:
28733         case IDENTIFIER:
28734         case QUOTED_LITERAL:
28735         case SQLDATA_CLASS:
28736         case CUSTOMDATUM_CLASS:
28737         case ORADATA_CLASS:
28738         case JAVA_INTERFACE_CLASS:
28739           ;
28740           break;
28741         default:
28742           jj_la1[439] = jj_gen;
28743           break label_101;
28744         }
28745         switch (jj_nt.kind) {
28746         case AFTER:
28747         case BEFORE:
28748         case INSTEADOF:
28749           TriggerTimingPointSection();
28750           break;
28751         case PRAGMA:
28752           Pragma();
28753           break;
28754         default:
28755           jj_la1[440] = jj_gen;
28756           if (jj_2_80(2)) {
28757             ExceptionDeclaration();
28758           } else if (jj_2_81(2)) {
28759             SubTypeDefinition();
28760           } else if (jj_2_82(4)) {
28761             VariableOrConstantDeclaration();
28762           } else if (jj_2_83(2)) {
28763             CursorSpecification();
28764           } else {
28765             switch (jj_nt.kind) {
28766             case CURSOR:
28767               CursorBody();
28768               break;
28769             case IDENTIFIER:
28770               CollectionDeclaration();
28771               break;
28772             case CREATE:
28773             case FUNCTION:
28774             case PROCEDURE:
28775               ProgramUnit();
28776               break;
28777             default:
28778               jj_la1[441] = jj_gen;
28779               jj_consume_token(-1);
28780               throw new ParseException();
28781             }
28782           }
28783         }
28784       }
28785       jj_consume_token(END);
28786       switch (jj_nt.kind) {
28787       case REPLACE:
28788       case DEFINER:
28789       case CURRENT_USER:
28790       case SERIALLY_REUSABLE:
28791       case RESTRICT_REFERENCES:
28792       case EXCEPTION_INIT:
28793       case AUTONOMOUS_TRANSACTION:
28794       case LANGUAGE:
28795       case INLINE:
28796       case ADD:
28797       case AGGREGATE:
28798       case ALL:
28799       case ALTER:
28800       case AND:
28801       case ANY:
28802       case ARRAY:
28803       case AS:
28804       case ASC:
28805       case AT:
28806       case ATTRIBUTE:
28807       case AUTHID:
28808       case AVG:
28809       case BETWEEN:
28810       case BINARY_INTEGER:
28811       case BODY:
28812       case BOOLEAN:
28813       case BULK:
28814       case BY:
28815       case BYTE:
28816       case CASCADE:
28817       case CASE:
28818       case CHAR:
28819       case CHAR_BASE:
28820       case CHECK:
28821       case CLOSE:
28822       case CLUSTER:
28823       case COALESCE:
28824       case COLLECT:
28825       case COLUMN:
28826       case COMMENT:
28827       case COMMIT:
28828       case COMPRESS:
28829       case CONNECT:
28830       case CONSTANT:
28831       case CONSTRUCTOR:
28832       case CONTINUE:
28833       case CONVERT:
28834       case CREATE:
28835       case CURRENT:
28836       case CURRVAL:
28837       case CURSOR:
28838       case DATA:
28839       case DATE:
28840       case DAY:
28841       case DECLARE:
28842       case DECIMAL:
28843       case _DEFAULT:
28844       case DELETE:
28845       case DESC:
28846       case DISABLE:
28847       case DISTINCT:
28848       case DO:
28849       case DROP:
28850       case EDITIONABLE:
28851       case ELEMENT:
28852       case ELSE:
28853       case ELSIF:
28854       case ENABLE:
28855       case ESCAPE:
28856       case EXCEPT:
28857       case EXCEPTION:
28858       case EXCEPTIONS:
28859       case EXCLUSIVE:
28860       case EXECUTE:
28861       case EXISTS:
28862       case EXIT:
28863       case EXTERNAL:
28864       case EXTENDS:
28865       case EXTRACT:
28866       case FALSE:
28867       case FETCH:
28868       case FINAL:
28869       case FLOAT:
28870       case FOR:
28871       case FORALL:
28872       case FORCE:
28873       case FROM:
28874       case FUNCTION:
28875       case GLOBAL:
28876       case GOTO:
28877       case GROUP:
28878       case HASH:
28879       case HAVING:
28880       case HEAP:
28881       case HOUR:
28882       case IF:
28883       case IMMEDIATE:
28884       case IN:
28885       case INDEX:
28886       case INDICES:
28887       case INDEXTYPE:
28888       case INDICATOR:
28889       case INSERT:
28890       case INSTANTIABLE:
28891       case INTEGER:
28892       case INTERFACE:
28893       case INTERSECT:
28894       case INTERVAL:
28895       case INTO:
28896       case INVALIDATE:
28897       case IS:
28898       case ISOLATION:
28899       case JAVA:
28900       case LEVEL:
28901       case LIKE:
28902       case LIMIT:
28903       case LIMITED:
28904       case LOCK:
28905       case LONG:
28906       case LOOP:
28907       case MAP:
28908       case MAX:
28909       case MEMBER:
28910       case MERGE:
28911       case MIN:
28912       case MINUS:
28913       case MINUTE:
28914       case MLSLABEL:
28915       case MODIFY:
28916       case MOD:
28917       case MODE:
28918       case MONTH:
28919       case NATURAL:
28920       case NATURALN:
28921       case NEW:
28922       case NEXTVAL:
28923       case NO:
28924       case NOCOPY:
28925       case NONEDITIONABLE:
28926       case NOT:
28927       case NOWAIT:
28928       case NULL:
28929       case NULLIF:
28930       case NUMBER:
28931       case BFILE_BASE:
28932       case BLOB_BASE:
28933       case CLOB_BASE:
28934       case DATE_BASE:
28935       case NUMBER_BASE:
28936       case OBJECT:
28937       case OCIROWID:
28938       case OF:
28939       case OID:
28940       case ON:
28941       case OPAQUE:
28942       case OPEN:
28943       case OPERATOR:
28944       case OPTION:
28945       case OR:
28946       case ORDER:
28947       case ORGANIZATION:
28948       case OTHERS:
28949       case OUT:
28950       case OVERRIDING:
28951       case PACKAGE:
28952       case PARTITION:
28953       case PCTFREE:
28954       case PLS_INTEGER:
28955       case POSITIVE:
28956       case POSITIVEN:
28957       case PRESERVE:
28958       case PRIOR:
28959       case PROMPT:
28960       case PRIVATE:
28961       case PROCEDURE:
28962       case PUBLIC:
28963       case RAISE:
28964       case RANGE:
28965       case RAW:
28966       case REAL:
28967       case RECORD:
28968       case REF:
28969       case RELEASE:
28970       case RELIES_ON:
28971       case RENAME:
28972       case RESULT:
28973       case RETURN:
28974       case RETURNING:
28975       case REVERSE:
28976       case ROLLBACK:
28977       case ROW:
28978       case ROWS:
28979       case ROWID:
28980       case ROWNUM:
28981       case ROWTYPE:
28982       case SAVE:
28983       case SAVEPOINT:
28984       case SECOND:
28985       case SELECT:
28986       case SELF:
28987       case SEPARATE:
28988       case SET:
28989       case SHARE:
28990       case SMALLINT:
28991       case SPACE:
28992       case SQL:
28993       case SQLCODE:
28994       case SQLERRM:
28995       case START:
28996       case STATIC:
28997       case STDDEV:
28998       case SUBTYPE:
28999       case SUBSTITUTABLE:
29000       case SUCCESSFUL:
29001       case SUM:
29002       case SYNONYM:
29003       case SYSDATE:
29004       case SYS_REFCURSOR:
29005       case TABLE:
29006       case TEMPORARY:
29007       case THEN:
29008       case TIME:
29009       case TIMESTAMP:
29010       case TIMEZONE_REGION:
29011       case TIMEZONE_ABBR:
29012       case TIMEZONE_MINUTE:
29013       case TIMEZONE_HOUR:
29014       case TO:
29015       case TRANSACTION:
29016       case TRIGGER:
29017       case TRUE:
29018       case TYPE:
29019       case UI:
29020       case UNDER:
29021       case USING:
29022       case WHILE:
29023       case YES:
29024       case SHOW:
29025       case A:
29026       case UPDATE:
29027       case VARCHAR:
29028       case VARCHAR2:
29029       case DOUBLE:
29030       case DEC:
29031       case PRECISION:
29032       case INT:
29033       case NUMERIC:
29034       case SIGNTYPE:
29035       case NCHAR:
29036       case NVARCHAR2:
29037       case STRING:
29038       case UROWID:
29039       case VARRAY:
29040       case VARYING:
29041       case BFILE:
29042       case BLOB:
29043       case CLOB:
29044       case NCLOB:
29045       case YEAR:
29046       case LOCAL:
29047       case WITH:
29048       case ZONE:
29049       case CHARACTER:
29050       case AFTER:
29051       case BEFORE:
29052       case OLD:
29053       case PARENT:
29054       case ANALYZE:
29055       case ASSOCIATE:
29056       case AUDIT:
29057       case COMPOUND:
29058       case DATABASE:
29059       case CALL:
29060       case DDL:
29061       case DISASSOCIATE:
29062       case EACH:
29063       case FOLLOWS:
29064       case LOGOFF:
29065       case LOGON:
29066       case NESTED:
29067       case NOAUDIT:
29068       case SCHEMA:
29069       case SERVERERROR:
29070       case SHUTDOWN:
29071       case STARTUP:
29072       case STATEMENT:
29073       case STATISTICS:
29074       case SUSPEND:
29075       case TRUNCATE:
29076       case WRAPPED:
29077       case LIBRARY:
29078       case NAME:
29079       case STRUCT:
29080       case CONTEXT:
29081       case PARAMETERS:
29082       case LENGTH:
29083       case TDO:
29084       case MAXLEN:
29085       case CHARSETID:
29086       case CHARSETFORM:
29087       case ACCEPT:
29088       case ACCESSIBLE:
29089       case COPY:
29090       case DEFINE:
29091       case DISCONNECT:
29092       case HOST:
29093       case PRINT:
29094       case QUIT:
29095       case REMARK:
29096       case UNDEFINE:
29097       case VARIABLE:
29098       case WHENEVER:
29099       case ATTACH:
29100       case CAST:
29101       case TREAT:
29102       case TRIM:
29103       case LEFT:
29104       case RIGHT:
29105       case BOTH:
29106       case EMPTY:
29107       case MULTISET:
29108       case SUBMULTISET:
29109       case LEADING:
29110       case TRAILING:
29111       case CHAR_CS:
29112       case NCHAR_CS:
29113       case DBTIMEZONE:
29114       case SESSIONTIMEZONE:
29115       case AUTHENTICATED:
29116       case LINK:
29117       case SHARED:
29118       case DIRECTORY:
29119       case USER:
29120       case IDENTIFIER:
29121       case QUOTED_LITERAL:
29122       case SQLDATA_CLASS:
29123       case CUSTOMDATUM_CLASS:
29124       case ORADATA_CLASS:
29125       case JAVA_INTERFACE_CLASS:
29126         ID();
29127         break;
29128       default:
29129         jj_la1[442] = jj_gen;
29130         ;
29131       }
29132       jj_consume_token(4);
29133         jjtree.closeNodeScope(jjtn000, true);
29134         jjtc000 = false;
29135         {if (true) return jjtn000 ;}
29136     } catch (Throwable jjte000) {
29137     if (jjtc000) {
29138       jjtree.clearNodeScope(jjtn000);
29139       jjtc000 = false;
29140     } else {
29141       jjtree.popNode();
29142     }
29143     if (jjte000 instanceof RuntimeException) {
29144       {if (true) throw (RuntimeException)jjte000;}
29145     }
29146     if (jjte000 instanceof ParseException) {
29147       {if (true) throw (ParseException)jjte000;}
29148     }
29149     {if (true) throw (Error)jjte000;}
29150     } finally {
29151     if (jjtc000) {
29152       jjtree.closeNodeScope(jjtn000, true);
29153     }
29154     }
29155     throw new Error("Missing return statement in function");
29156   }
29157 
29158 /*
29159 non_dml_trigger :
29160 (BEFORE> |<AFTER> ) 
29161 (DDLEvent | database_event) ( OR (DDLEvent | database_event))*
29162 ON
29163 (DATABASE | [schema.]SCHEMA
29164 */
29165   final public ASTNonDMLTrigger NonDMLTrigger() throws ParseException {
29166  /*@bgen(jjtree) NonDMLTrigger */
29167   ASTNonDMLTrigger jjtn000 = new ASTNonDMLTrigger(this, JJTNONDMLTRIGGER);
29168   boolean jjtc000 = true;
29169   jjtree.openNodeScope(jjtn000);
29170     try {
29171       switch (jj_nt.kind) {
29172       case BEFORE:
29173         jj_consume_token(BEFORE);
29174         break;
29175       case AFTER:
29176         jj_consume_token(AFTER);
29177         break;
29178       default:
29179         jj_la1[443] = jj_gen;
29180         jj_consume_token(-1);
29181         throw new ParseException();
29182       }
29183       switch (jj_nt.kind) {
29184       case ALTER:
29185       case COMMENT:
29186       case CREATE:
29187       case DROP:
29188       case GRANT:
29189       case RENAME:
29190       case REVOKE:
29191       case ANALYZE:
29192       case ASSOCIATE:
29193       case AUDIT:
29194       case DDL:
29195       case DISASSOCIATE:
29196       case NOAUDIT:
29197       case TRUNCATE:
29198         DDLEvent();
29199         break;
29200       case LOGOFF:
29201       case LOGON:
29202       case SERVERERROR:
29203       case SHUTDOWN:
29204       case STARTUP:
29205       case SUSPEND:
29206         DatabaseEvent();
29207         break;
29208       default:
29209         jj_la1[444] = jj_gen;
29210         jj_consume_token(-1);
29211         throw new ParseException();
29212       }
29213       label_102:
29214       while (true) {
29215         switch (jj_nt.kind) {
29216         case OR:
29217           ;
29218           break;
29219         default:
29220           jj_la1[445] = jj_gen;
29221           break label_102;
29222         }
29223         jj_consume_token(OR);
29224         switch (jj_nt.kind) {
29225         case ALTER:
29226         case COMMENT:
29227         case CREATE:
29228         case DROP:
29229         case GRANT:
29230         case RENAME:
29231         case REVOKE:
29232         case ANALYZE:
29233         case ASSOCIATE:
29234         case AUDIT:
29235         case DDL:
29236         case DISASSOCIATE:
29237         case NOAUDIT:
29238         case TRUNCATE:
29239           DDLEvent();
29240           break;
29241         case LOGOFF:
29242         case LOGON:
29243         case SERVERERROR:
29244         case SHUTDOWN:
29245         case STARTUP:
29246         case SUSPEND:
29247           DatabaseEvent();
29248           break;
29249         default:
29250           jj_la1[446] = jj_gen;
29251           jj_consume_token(-1);
29252           throw new ParseException();
29253         }
29254       }
29255       jj_consume_token(ON);
29256       switch (jj_nt.kind) {
29257       case DATABASE:
29258         jj_consume_token(DATABASE);
29259         break;
29260       case REPLACE:
29261       case DEFINER:
29262       case CURRENT_USER:
29263       case SERIALLY_REUSABLE:
29264       case RESTRICT_REFERENCES:
29265       case EXCEPTION_INIT:
29266       case AUTONOMOUS_TRANSACTION:
29267       case LANGUAGE:
29268       case INLINE:
29269       case ADD:
29270       case AGGREGATE:
29271       case ALL:
29272       case ALTER:
29273       case AND:
29274       case ANY:
29275       case ARRAY:
29276       case AS:
29277       case ASC:
29278       case AT:
29279       case ATTRIBUTE:
29280       case AUTHID:
29281       case AVG:
29282       case BETWEEN:
29283       case BINARY_INTEGER:
29284       case BODY:
29285       case BOOLEAN:
29286       case BULK:
29287       case BY:
29288       case BYTE:
29289       case CASCADE:
29290       case CASE:
29291       case CHAR:
29292       case CHAR_BASE:
29293       case CHECK:
29294       case CLOSE:
29295       case CLUSTER:
29296       case COALESCE:
29297       case COLLECT:
29298       case COLUMN:
29299       case COMMENT:
29300       case COMMIT:
29301       case COMPRESS:
29302       case CONNECT:
29303       case CONSTANT:
29304       case CONSTRUCTOR:
29305       case CONTINUE:
29306       case CONVERT:
29307       case CREATE:
29308       case CURRENT:
29309       case CURRVAL:
29310       case CURSOR:
29311       case DATA:
29312       case DATE:
29313       case DAY:
29314       case DECLARE:
29315       case DECIMAL:
29316       case _DEFAULT:
29317       case DELETE:
29318       case DESC:
29319       case DISABLE:
29320       case DISTINCT:
29321       case DO:
29322       case DROP:
29323       case EDITIONABLE:
29324       case ELEMENT:
29325       case ELSE:
29326       case ELSIF:
29327       case ENABLE:
29328       case ESCAPE:
29329       case EXCEPT:
29330       case EXCEPTION:
29331       case EXCEPTIONS:
29332       case EXCLUSIVE:
29333       case EXECUTE:
29334       case EXISTS:
29335       case EXIT:
29336       case EXTERNAL:
29337       case EXTENDS:
29338       case EXTRACT:
29339       case FALSE:
29340       case FETCH:
29341       case FINAL:
29342       case FLOAT:
29343       case FOR:
29344       case FORALL:
29345       case FORCE:
29346       case FROM:
29347       case FUNCTION:
29348       case GLOBAL:
29349       case GOTO:
29350       case GROUP:
29351       case HASH:
29352       case HAVING:
29353       case HEAP:
29354       case HOUR:
29355       case IF:
29356       case IMMEDIATE:
29357       case IN:
29358       case INDEX:
29359       case INDICES:
29360       case INDEXTYPE:
29361       case INDICATOR:
29362       case INSERT:
29363       case INSTANTIABLE:
29364       case INTEGER:
29365       case INTERFACE:
29366       case INTERSECT:
29367       case INTERVAL:
29368       case INTO:
29369       case INVALIDATE:
29370       case IS:
29371       case ISOLATION:
29372       case JAVA:
29373       case LEVEL:
29374       case LIKE:
29375       case LIMIT:
29376       case LIMITED:
29377       case LOCK:
29378       case LONG:
29379       case LOOP:
29380       case MAP:
29381       case MAX:
29382       case MEMBER:
29383       case MERGE:
29384       case MIN:
29385       case MINUS:
29386       case MINUTE:
29387       case MLSLABEL:
29388       case MODIFY:
29389       case MOD:
29390       case MODE:
29391       case MONTH:
29392       case NATURAL:
29393       case NATURALN:
29394       case NEW:
29395       case NEXTVAL:
29396       case NO:
29397       case NOCOPY:
29398       case NONEDITIONABLE:
29399       case NOT:
29400       case NOWAIT:
29401       case NULL:
29402       case NULLIF:
29403       case NUMBER:
29404       case BFILE_BASE:
29405       case BLOB_BASE:
29406       case CLOB_BASE:
29407       case DATE_BASE:
29408       case NUMBER_BASE:
29409       case OBJECT:
29410       case OCIROWID:
29411       case OF:
29412       case OID:
29413       case ON:
29414       case OPAQUE:
29415       case OPEN:
29416       case OPERATOR:
29417       case OPTION:
29418       case OR:
29419       case ORDER:
29420       case ORGANIZATION:
29421       case OTHERS:
29422       case OUT:
29423       case OVERRIDING:
29424       case PACKAGE:
29425       case PARTITION:
29426       case PCTFREE:
29427       case PLS_INTEGER:
29428       case POSITIVE:
29429       case POSITIVEN:
29430       case PRESERVE:
29431       case PRIOR:
29432       case PROMPT:
29433       case PRIVATE:
29434       case PROCEDURE:
29435       case PUBLIC:
29436       case RAISE:
29437       case RANGE:
29438       case RAW:
29439       case REAL:
29440       case RECORD:
29441       case REF:
29442       case RELEASE:
29443       case RELIES_ON:
29444       case RENAME:
29445       case RESULT:
29446       case RETURN:
29447       case RETURNING:
29448       case REVERSE:
29449       case ROLLBACK:
29450       case ROW:
29451       case ROWS:
29452       case ROWID:
29453       case ROWNUM:
29454       case ROWTYPE:
29455       case SAVE:
29456       case SAVEPOINT:
29457       case SECOND:
29458       case SELECT:
29459       case SELF:
29460       case SEPARATE:
29461       case SET:
29462       case SHARE:
29463       case SMALLINT:
29464       case SPACE:
29465       case SQL:
29466       case SQLCODE:
29467       case SQLERRM:
29468       case START:
29469       case STATIC:
29470       case STDDEV:
29471       case SUBTYPE:
29472       case SUBSTITUTABLE:
29473       case SUCCESSFUL:
29474       case SUM:
29475       case SYNONYM:
29476       case SYSDATE:
29477       case SYS_REFCURSOR:
29478       case TABLE:
29479       case TEMPORARY:
29480       case THEN:
29481       case TIME:
29482       case TIMESTAMP:
29483       case TIMEZONE_REGION:
29484       case TIMEZONE_ABBR:
29485       case TIMEZONE_MINUTE:
29486       case TIMEZONE_HOUR:
29487       case TO:
29488       case TRANSACTION:
29489       case TRIGGER:
29490       case TRUE:
29491       case TYPE:
29492       case UI:
29493       case UNDER:
29494       case USING:
29495       case WHILE:
29496       case YES:
29497       case SHOW:
29498       case A:
29499       case UPDATE:
29500       case VARCHAR:
29501       case VARCHAR2:
29502       case DOUBLE:
29503       case DEC:
29504       case PRECISION:
29505       case INT:
29506       case NUMERIC:
29507       case SIGNTYPE:
29508       case NCHAR:
29509       case NVARCHAR2:
29510       case STRING:
29511       case UROWID:
29512       case VARRAY:
29513       case VARYING:
29514       case BFILE:
29515       case BLOB:
29516       case CLOB:
29517       case NCLOB:
29518       case YEAR:
29519       case LOCAL:
29520       case WITH:
29521       case ZONE:
29522       case CHARACTER:
29523       case AFTER:
29524       case BEFORE:
29525       case OLD:
29526       case PARENT:
29527       case ANALYZE:
29528       case ASSOCIATE:
29529       case AUDIT:
29530       case COMPOUND:
29531       case CALL:
29532       case DDL:
29533       case DISASSOCIATE:
29534       case EACH:
29535       case FOLLOWS:
29536       case LOGOFF:
29537       case LOGON:
29538       case NESTED:
29539       case NOAUDIT:
29540       case SCHEMA:
29541       case SERVERERROR:
29542       case SHUTDOWN:
29543       case STARTUP:
29544       case STATEMENT:
29545       case STATISTICS:
29546       case SUSPEND:
29547       case TRUNCATE:
29548       case WRAPPED:
29549       case LIBRARY:
29550       case NAME:
29551       case STRUCT:
29552       case CONTEXT:
29553       case PARAMETERS:
29554       case LENGTH:
29555       case TDO:
29556       case MAXLEN:
29557       case CHARSETID:
29558       case CHARSETFORM:
29559       case ACCEPT:
29560       case ACCESSIBLE:
29561       case COPY:
29562       case DEFINE:
29563       case DISCONNECT:
29564       case HOST:
29565       case PRINT:
29566       case QUIT:
29567       case REMARK:
29568       case UNDEFINE:
29569       case VARIABLE:
29570       case WHENEVER:
29571       case ATTACH:
29572       case CAST:
29573       case TREAT:
29574       case TRIM:
29575       case LEFT:
29576       case RIGHT:
29577       case BOTH:
29578       case EMPTY:
29579       case MULTISET:
29580       case SUBMULTISET:
29581       case LEADING:
29582       case TRAILING:
29583       case CHAR_CS:
29584       case NCHAR_CS:
29585       case DBTIMEZONE:
29586       case SESSIONTIMEZONE:
29587       case AUTHENTICATED:
29588       case LINK:
29589       case SHARED:
29590       case DIRECTORY:
29591       case USER:
29592       case IDENTIFIER:
29593       case QUOTED_LITERAL:
29594       case SQLDATA_CLASS:
29595       case CUSTOMDATUM_CLASS:
29596       case ORADATA_CLASS:
29597       case JAVA_INTERFACE_CLASS:
29598         if (jj_2_84(2)) {
29599           ID();
29600           jj_consume_token(3);
29601         } else {
29602           ;
29603         }
29604         jj_consume_token(SCHEMA);
29605         break;
29606       default:
29607         jj_la1[447] = jj_gen;
29608         jj_consume_token(-1);
29609         throw new ParseException();
29610       }
29611         jjtree.closeNodeScope(jjtn000, true);
29612         jjtc000 = false;
29613         {if (true) return jjtn000 ;}
29614     } catch (Throwable jjte000) {
29615    if (jjtc000) {
29616      jjtree.clearNodeScope(jjtn000);
29617      jjtc000 = false;
29618    } else {
29619      jjtree.popNode();
29620    }
29621    if (jjte000 instanceof RuntimeException) {
29622      {if (true) throw (RuntimeException)jjte000;}
29623    }
29624    if (jjte000 instanceof ParseException) {
29625      {if (true) throw (ParseException)jjte000;}
29626    }
29627    {if (true) throw (Error)jjte000;}
29628     } finally {
29629    if (jjtc000) {
29630      jjtree.closeNodeScope(jjtn000, true);
29631    }
29632     }
29633     throw new Error("Missing return statement in function");
29634   }
29635 
29636   final public ASTDDLEvent DDLEvent() throws ParseException {
29637                          /*@bgen(jjtree) DDLEvent */
29638   ASTDDLEvent jjtn000 = new ASTDDLEvent(this, JJTDDLEVENT);
29639   boolean jjtc000 = true;
29640   jjtree.openNodeScope(jjtn000);
29641     try {
29642       switch (jj_nt.kind) {
29643       case ALTER:
29644         jj_consume_token(ALTER);
29645         break;
29646       case ANALYZE:
29647         jj_consume_token(ANALYZE);
29648         break;
29649       case ASSOCIATE:
29650         jj_consume_token(ASSOCIATE);
29651         jj_consume_token(STATISTICS);
29652         break;
29653       case AUDIT:
29654         jj_consume_token(AUDIT);
29655         break;
29656       case COMMENT:
29657         jj_consume_token(COMMENT);
29658         break;
29659       case CREATE:
29660         jj_consume_token(CREATE);
29661         break;
29662       case DISASSOCIATE:
29663         jj_consume_token(DISASSOCIATE);
29664         jj_consume_token(STATISTICS);
29665         break;
29666       case DROP:
29667         jj_consume_token(DROP);
29668         break;
29669       case GRANT:
29670         jj_consume_token(GRANT);
29671         break;
29672       case NOAUDIT:
29673         jj_consume_token(NOAUDIT);
29674         break;
29675       case RENAME:
29676         jj_consume_token(RENAME);
29677         break;
29678       case REVOKE:
29679         jj_consume_token(REVOKE);
29680         break;
29681       case TRUNCATE:
29682         jj_consume_token(TRUNCATE);
29683         break;
29684       case DDL:
29685         jj_consume_token(DDL);
29686         break;
29687       default:
29688         jj_la1[448] = jj_gen;
29689         jj_consume_token(-1);
29690         throw new ParseException();
29691       }
29692           jjtree.closeNodeScope(jjtn000, true);
29693           jjtc000 = false;
29694           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
29695     } finally {
29696     if (jjtc000) {
29697       jjtree.closeNodeScope(jjtn000, true);
29698     }
29699     }
29700     throw new Error("Missing return statement in function");
29701   }
29702 
29703   final public ASTDatabaseEvent DatabaseEvent() throws ParseException {
29704                                    /*@bgen(jjtree) DatabaseEvent */
29705   ASTDatabaseEvent jjtn000 = new ASTDatabaseEvent(this, JJTDATABASEEVENT);
29706   boolean jjtc000 = true;
29707   jjtree.openNodeScope(jjtn000);
29708     try {
29709       switch (jj_nt.kind) {
29710       case STARTUP:
29711         jj_consume_token(STARTUP);
29712         break;
29713       case SHUTDOWN:
29714         jj_consume_token(SHUTDOWN);
29715         break;
29716       case LOGON:
29717         jj_consume_token(LOGON);
29718         break;
29719       case LOGOFF:
29720         jj_consume_token(LOGOFF);
29721         break;
29722       case SERVERERROR:
29723         jj_consume_token(SERVERERROR);
29724         break;
29725       case SUSPEND:
29726         jj_consume_token(SUSPEND);
29727         break;
29728       default:
29729         jj_la1[449] = jj_gen;
29730         jj_consume_token(-1);
29731         throw new ParseException();
29732       }
29733           jjtree.closeNodeScope(jjtn000, true);
29734           jjtc000 = false;
29735           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
29736     } finally {
29737     if (jjtc000) {
29738       jjtree.closeNodeScope(jjtn000, true);
29739     }
29740     }
29741     throw new Error("Missing return statement in function");
29742   }
29743 
29744   final public ASTNonDMLEvent NonDMLEvent() throws ParseException {
29745                                /*@bgen(jjtree) NonDMLEvent */
29746   ASTNonDMLEvent jjtn000 = new ASTNonDMLEvent(this, JJTNONDMLEVENT);
29747   boolean jjtc000 = true;
29748   jjtree.openNodeScope(jjtn000);
29749     try {
29750       switch (jj_nt.kind) {
29751       case ALTER:
29752       case COMMENT:
29753       case CREATE:
29754       case DROP:
29755       case GRANT:
29756       case RENAME:
29757       case REVOKE:
29758       case ANALYZE:
29759       case ASSOCIATE:
29760       case AUDIT:
29761       case DDL:
29762       case DISASSOCIATE:
29763       case NOAUDIT:
29764       case TRUNCATE:
29765         DDLEvent();
29766         break;
29767       case LOGOFF:
29768       case LOGON:
29769       case SERVERERROR:
29770       case SHUTDOWN:
29771       case STARTUP:
29772       case SUSPEND:
29773         DatabaseEvent();
29774         break;
29775       default:
29776         jj_la1[450] = jj_gen;
29777         jj_consume_token(-1);
29778         throw new ParseException();
29779       }
29780     jjtree.closeNodeScope(jjtn000, true);
29781     jjtc000 = false;
29782     {if (true) return jjtn000;}
29783     } catch (Throwable jjte000) {
29784     if (jjtc000) {
29785       jjtree.clearNodeScope(jjtn000);
29786       jjtc000 = false;
29787     } else {
29788       jjtree.popNode();
29789     }
29790     if (jjte000 instanceof RuntimeException) {
29791       {if (true) throw (RuntimeException)jjte000;}
29792     }
29793     if (jjte000 instanceof ParseException) {
29794       {if (true) throw (ParseException)jjte000;}
29795     }
29796     {if (true) throw (Error)jjte000;}
29797     } finally {
29798     if (jjtc000) {
29799       jjtree.closeNodeScope(jjtn000, true);
29800     }
29801     }
29802     throw new Error("Missing return statement in function");
29803   }
29804 
29805 /*
29806 When DBMS_METADATA.GET_DDL returns a trigger, it can come in 2 DDL statements.
29807 The first is the CREATE OR REPLACE TRIGER statement; the second is an ALTER TRIGGER statement,
29808 enabling or disabling the trigger.
29809 
29810 Unlike the ALTER TYPE, it does not seem to alter the structure of the object.
29811 */
29812   final public void AlterTrigger() throws ParseException {
29813  /*@bgen(jjtree) AlterTrigger */
29814   ASTAlterTrigger jjtn000 = new ASTAlterTrigger(this, JJTALTERTRIGGER);
29815   boolean jjtc000 = true;
29816   jjtree.openNodeScope(jjtn000);
29817     try {
29818       jj_consume_token(ALTER);
29819       jj_consume_token(TRIGGER);
29820       Skip2NextTerminator(null,";");
29821       jj_consume_token(4);
29822           jjtree.closeNodeScope(jjtn000, true);
29823           jjtc000 = false;
29824                 {if (true) return;}
29825     } catch (Throwable jjte000) {
29826           if (jjtc000) {
29827             jjtree.clearNodeScope(jjtn000);
29828             jjtc000 = false;
29829           } else {
29830             jjtree.popNode();
29831           }
29832           if (jjte000 instanceof RuntimeException) {
29833             {if (true) throw (RuntimeException)jjte000;}
29834           }
29835           if (jjte000 instanceof ParseException) {
29836             {if (true) throw (ParseException)jjte000;}
29837           }
29838           {if (true) throw (Error)jjte000;}
29839     } finally {
29840           if (jjtc000) {
29841             jjtree.closeNodeScope(jjtn000, true);
29842           }
29843     }
29844   }
29845 
29846 //SRT 2011-04-17 - START 
29847   final public ASTKEYWORD_RESERVED KEYWORD_RESERVED() throws ParseException {
29848                                           /*@bgen(jjtree) KEYWORD_RESERVED */
29849   ASTKEYWORD_RESERVED jjtn000 = new ASTKEYWORD_RESERVED(this, JJTKEYWORD_RESERVED);
29850   boolean jjtc000 = true;
29851   jjtree.openNodeScope(jjtn000);
29852     try {
29853       switch (jj_nt.kind) {
29854       case ALL:
29855         jj_consume_token(ALL);
29856         break;
29857       case ALTER:
29858         jj_consume_token(ALTER);
29859         break;
29860       case AND:
29861         jj_consume_token(AND);
29862         break;
29863       case ANY:
29864         jj_consume_token(ANY);
29865         break;
29866       case AS:
29867         jj_consume_token(AS);
29868         break;
29869       case ASC:
29870         jj_consume_token(ASC);
29871         break;
29872       case BETWEEN:
29873         jj_consume_token(BETWEEN);
29874         break;
29875       case BY:
29876         jj_consume_token(BY);
29877         break;
29878       case CHAR:
29879         jj_consume_token(CHAR);
29880         break;
29881       case CHECK:
29882         jj_consume_token(CHECK);
29883         break;
29884       case CLUSTER:
29885         jj_consume_token(CLUSTER);
29886         break;
29887       case COMPRESS:
29888         jj_consume_token(COMPRESS);
29889         break;
29890       case CONNECT:
29891         jj_consume_token(CONNECT);
29892         break;
29893       case CREATE:
29894         jj_consume_token(CREATE);
29895         break;
29896       case DATE:
29897         jj_consume_token(DATE);
29898         break;
29899       case DECIMAL:
29900         jj_consume_token(DECIMAL);
29901         break;
29902       case _DEFAULT:
29903         jj_consume_token(_DEFAULT);
29904         break;
29905       case DELETE:
29906         jj_consume_token(DELETE);
29907         break;
29908       case DESC:
29909         jj_consume_token(DESC);
29910         break;
29911       case DISTINCT:
29912         jj_consume_token(DISTINCT);
29913         break;
29914       case DROP:
29915         jj_consume_token(DROP);
29916         break;
29917       case ELSE:
29918         jj_consume_token(ELSE);
29919         break;
29920       case EXCLUSIVE:
29921         jj_consume_token(EXCLUSIVE);
29922         break;
29923       case EXISTS:
29924         jj_consume_token(EXISTS);
29925         break;
29926       case FLOAT:
29927         jj_consume_token(FLOAT);
29928         break;
29929       case FOR:
29930         jj_consume_token(FOR);
29931         break;
29932       case FROM:
29933         jj_consume_token(FROM);
29934         break;
29935       case GRANT:
29936         jj_consume_token(GRANT);
29937         break;
29938       case GROUP:
29939         jj_consume_token(GROUP);
29940         break;
29941       case HAVING:
29942         jj_consume_token(HAVING);
29943         break;
29944       case IDENTIFIED:
29945         jj_consume_token(IDENTIFIED);
29946         break;
29947       case IN:
29948         jj_consume_token(IN);
29949         break;
29950       case INDEX:
29951         jj_consume_token(INDEX);
29952         break;
29953       case INSERT:
29954         jj_consume_token(INSERT);
29955         break;
29956       case INTEGER:
29957         jj_consume_token(INTEGER);
29958         break;
29959       case INTERSECT:
29960         jj_consume_token(INTERSECT);
29961         break;
29962       case INTO:
29963         jj_consume_token(INTO);
29964         break;
29965       case IS:
29966         jj_consume_token(IS);
29967         break;
29968       case LIKE:
29969         jj_consume_token(LIKE);
29970         break;
29971       case LOCK:
29972         jj_consume_token(LOCK);
29973         break;
29974       case LONG:
29975         jj_consume_token(LONG);
29976         break;
29977       case MINUS:
29978         jj_consume_token(MINUS);
29979         break;
29980       case MODE:
29981         jj_consume_token(MODE);
29982         break;
29983       case NOCOMPRESS:
29984         jj_consume_token(NOCOMPRESS);
29985         break;
29986       case NOT:
29987         jj_consume_token(NOT);
29988         break;
29989       case NOWAIT:
29990         jj_consume_token(NOWAIT);
29991         break;
29992       case NULL:
29993         jj_consume_token(NULL);
29994         break;
29995       case NUMBER:
29996         jj_consume_token(NUMBER);
29997         break;
29998       case OF:
29999         jj_consume_token(OF);
30000         break;
30001       case ON:
30002         jj_consume_token(ON);
30003         break;
30004       case OPTION:
30005         jj_consume_token(OPTION);
30006         break;
30007       case OR:
30008         jj_consume_token(OR);
30009         break;
30010       case ORDER:
30011         jj_consume_token(ORDER);
30012         break;
30013       case PCTFREE:
30014         jj_consume_token(PCTFREE);
30015         break;
30016       case PRIOR:
30017         jj_consume_token(PRIOR);
30018         break;
30019       case PUBLIC:
30020         jj_consume_token(PUBLIC);
30021         break;
30022       case RAW:
30023         jj_consume_token(RAW);
30024         break;
30025       case RESOURCE:
30026         jj_consume_token(RESOURCE);
30027         break;
30028       case REVOKE:
30029         jj_consume_token(REVOKE);
30030         break;
30031       case SELECT:
30032         jj_consume_token(SELECT);
30033         break;
30034       case SET:
30035         jj_consume_token(SET);
30036         break;
30037       case SHARE:
30038         jj_consume_token(SHARE);
30039         break;
30040       case SIZE:
30041         jj_consume_token(SIZE);
30042         break;
30043       case SMALLINT:
30044         jj_consume_token(SMALLINT);
30045         break;
30046       case START:
30047         jj_consume_token(START);
30048         break;
30049       case SYNONYM:
30050         jj_consume_token(SYNONYM);
30051         break;
30052       case TABLE:
30053         jj_consume_token(TABLE);
30054         break;
30055       case THEN:
30056         jj_consume_token(THEN);
30057         break;
30058       case TO:
30059         jj_consume_token(TO);
30060         break;
30061       case TRIGGER:
30062         jj_consume_token(TRIGGER);
30063         break;
30064       case UNION:
30065         jj_consume_token(UNION);
30066         break;
30067       case UNIQUE:
30068         jj_consume_token(UNIQUE);
30069         break;
30070       case UPDATE:
30071         jj_consume_token(UPDATE);
30072         break;
30073       case VALUES:
30074         jj_consume_token(VALUES);
30075         break;
30076       case VARCHAR:
30077         jj_consume_token(VARCHAR);
30078         break;
30079       case VARCHAR2:
30080         jj_consume_token(VARCHAR2);
30081         break;
30082       case VIEW:
30083         jj_consume_token(VIEW);
30084         break;
30085       case WHERE:
30086         jj_consume_token(WHERE);
30087         break;
30088       case WITH:
30089         jj_consume_token(WITH);
30090         break;
30091       default:
30092         jj_la1[451] = jj_gen;
30093         jj_consume_token(-1);
30094         throw new ParseException();
30095       }
30096    jjtree.closeNodeScope(jjtn000, true);
30097    jjtc000 = false;
30098    jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30099     } finally {
30100   if (jjtc000) {
30101     jjtree.closeNodeScope(jjtn000, true);
30102   }
30103     }
30104     throw new Error("Missing return statement in function");
30105   }
30106 
30107   final public ASTKEYWORD_UNRESERVED KEYWORD_UNRESERVED() throws ParseException {
30108                                               /*@bgen(jjtree) KEYWORD_UNRESERVED */
30109   ASTKEYWORD_UNRESERVED jjtn000 = new ASTKEYWORD_UNRESERVED(this, JJTKEYWORD_UNRESERVED);
30110   boolean jjtc000 = true;
30111   jjtree.openNodeScope(jjtn000);
30112     try {
30113       switch (jj_nt.kind) {
30114       case FALSE:
30115         jj_consume_token(FALSE);
30116         break;
30117       case TRUE:
30118         jj_consume_token(TRUE);
30119         break;
30120       case A:
30121         jj_consume_token(A);
30122         break;
30123       case ACCEPT:
30124         jj_consume_token(ACCEPT);
30125         break;
30126       case ADD:
30127         jj_consume_token(ADD);
30128         break;
30129       case AFTER:
30130         jj_consume_token(AFTER);
30131         break;
30132       case AGGREGATE:
30133         jj_consume_token(AGGREGATE);
30134         break;
30135       case ANALYZE:
30136         jj_consume_token(ANALYZE);
30137         break;
30138       case ASSOCIATE:
30139         jj_consume_token(ASSOCIATE);
30140         break;
30141       case AT:
30142         jj_consume_token(AT);
30143         break;
30144       case ATTACH:
30145         jj_consume_token(ATTACH);
30146         break;
30147       case ATTRIBUTE:
30148         jj_consume_token(ATTRIBUTE);
30149         break;
30150       case AUDIT:
30151         jj_consume_token(AUDIT);
30152         break;
30153       case AUTHENTICATED:
30154         jj_consume_token(AUTHENTICATED);
30155         break;
30156       case AUTHID:
30157         jj_consume_token(AUTHID);
30158         break;
30159       case BEFORE:
30160         jj_consume_token(BEFORE);
30161         break;
30162       case BFILE:
30163         jj_consume_token(BFILE);
30164         break;
30165       case BLOB:
30166         jj_consume_token(BLOB);
30167         break;
30168       case BOTH:
30169         jj_consume_token(BOTH);
30170         break;
30171       case BULK:
30172         jj_consume_token(BULK);
30173         break;
30174       case BYTE:
30175         jj_consume_token(BYTE);
30176         break;
30177       case CALL:
30178         jj_consume_token(CALL);
30179         break;
30180       case CASCADE:
30181         jj_consume_token(CASCADE);
30182         break;
30183       case CAST:
30184         jj_consume_token(CAST);
30185         break;
30186       case CHAR_CS:
30187         jj_consume_token(CHAR_CS);
30188         break;
30189       case CHARACTER:
30190         jj_consume_token(CHARACTER);
30191         break;
30192       case CHARSETFORM:
30193         jj_consume_token(CHARSETFORM);
30194         break;
30195       case CHARSETID:
30196         jj_consume_token(CHARSETID);
30197         break;
30198       case CLOB:
30199         jj_consume_token(CLOB);
30200         break;
30201       case CLOSE:
30202         jj_consume_token(CLOSE);
30203         break;
30204       case COALESCE:
30205         jj_consume_token(COALESCE);
30206         break;
30207       case COLLECT:
30208         jj_consume_token(COLLECT);
30209         break;
30210       case COLUMN:
30211         jj_consume_token(COLUMN);
30212         break;
30213       case COMMENT:
30214         jj_consume_token(COMMENT);
30215         break;
30216       case COMMIT:
30217         jj_consume_token(COMMIT);
30218         break;
30219       case COMPOUND:
30220         jj_consume_token(COMPOUND);
30221         break;
30222       case CONSTRUCTOR:
30223         jj_consume_token(CONSTRUCTOR);
30224         break;
30225       case CONTEXT:
30226         jj_consume_token(CONTEXT);
30227         break;
30228       case CONTINUE:
30229         jj_consume_token(CONTINUE);
30230         break;
30231       case CONVERT:
30232         jj_consume_token(CONVERT);
30233         break;
30234       case COPY:
30235         jj_consume_token(COPY);
30236         break;
30237       case CURRENT:
30238         jj_consume_token(CURRENT);
30239         break;
30240       case CURRENT_USER:
30241         jj_consume_token(CURRENT_USER);
30242         break;
30243       case CURSOR:
30244         jj_consume_token(CURSOR);
30245         break;
30246       case DATA:
30247         jj_consume_token(DATA);
30248         break;
30249       case DATABASE:
30250         jj_consume_token(DATABASE);
30251         break;
30252       case DAY:
30253         jj_consume_token(DAY);
30254         break;
30255       case DBTIMEZONE:
30256         jj_consume_token(DBTIMEZONE);
30257         break;
30258       case DDL:
30259         jj_consume_token(DDL);
30260         break;
30261       case DEC:
30262         jj_consume_token(DEC);
30263         break;
30264       case DEFINE:
30265         jj_consume_token(DEFINE);
30266         break;
30267       case DEFINER:
30268         jj_consume_token(DEFINER);
30269         break;
30270       case DIRECTORY:
30271         jj_consume_token(DIRECTORY);
30272         break;
30273       case DISABLE:
30274         jj_consume_token(DISABLE);
30275         break;
30276       case DISASSOCIATE:
30277         jj_consume_token(DISASSOCIATE);
30278         break;
30279       case DISCONNECT:
30280         jj_consume_token(DISCONNECT);
30281         break;
30282       case DOUBLE:
30283         jj_consume_token(DOUBLE);
30284         break;
30285       case EACH:
30286         jj_consume_token(EACH);
30287         break;
30288       case ELEMENT:
30289         jj_consume_token(ELEMENT);
30290         break;
30291       case EMPTY:
30292         jj_consume_token(EMPTY);
30293         break;
30294       case ENABLE:
30295         jj_consume_token(ENABLE);
30296         break;
30297       case ESCAPE:
30298         jj_consume_token(ESCAPE);
30299         break;
30300       case EXCEPT:
30301         jj_consume_token(EXCEPT);
30302         break;
30303       case EXCEPTIONS:
30304         jj_consume_token(EXCEPTIONS);
30305         break;
30306       case EXIT:
30307         jj_consume_token(EXIT);
30308         break;
30309       case EXTENDS:
30310         jj_consume_token(EXTENDS);
30311         break;
30312       case EXTERNAL:
30313         jj_consume_token(EXTERNAL);
30314         break;
30315       case EXTRACT:
30316         jj_consume_token(EXTRACT);
30317         break;
30318       case FINAL:
30319         jj_consume_token(FINAL);
30320         break;
30321       case FOLLOWS:
30322         jj_consume_token(FOLLOWS);
30323         break;
30324       case FORCE:
30325         jj_consume_token(FORCE);
30326         break;
30327       case FUNCTION:
30328         jj_consume_token(FUNCTION);
30329         break;
30330       case GLOBAL:
30331         jj_consume_token(GLOBAL);
30332         break;
30333       case HASH:
30334         jj_consume_token(HASH);
30335         break;
30336       case HEAP:
30337         jj_consume_token(HEAP);
30338         break;
30339       case HOST:
30340         jj_consume_token(HOST);
30341         break;
30342       case HOUR:
30343         jj_consume_token(HOUR);
30344         break;
30345       case IMMEDIATE:
30346         jj_consume_token(IMMEDIATE);
30347         break;
30348       case INDEXTYPE:
30349         jj_consume_token(INDEXTYPE);
30350         break;
30351       case INDICATOR:
30352         jj_consume_token(INDICATOR);
30353         break;
30354       case INDICES:
30355         jj_consume_token(INDICES);
30356         break;
30357       case INSTANTIABLE:
30358         jj_consume_token(INSTANTIABLE);
30359         break;
30360       case INTERVAL:
30361         jj_consume_token(INTERVAL);
30362         break;
30363       case INVALIDATE:
30364         jj_consume_token(INVALIDATE);
30365         break;
30366       case ISOLATION:
30367         jj_consume_token(ISOLATION);
30368         break;
30369       case JAVA:
30370         jj_consume_token(JAVA);
30371         break;
30372       case LANGUAGE:
30373         jj_consume_token(LANGUAGE);
30374         break;
30375       case LEADING:
30376         jj_consume_token(LEADING);
30377         break;
30378       case LEFT:
30379         jj_consume_token(LEFT);
30380         break;
30381       case LENGTH:
30382         jj_consume_token(LENGTH);
30383         break;
30384       case LEVEL:
30385         jj_consume_token(LEVEL);
30386         break;
30387       case LIBRARY:
30388         jj_consume_token(LIBRARY);
30389         break;
30390       case LIMIT:
30391         jj_consume_token(LIMIT);
30392         break;
30393       case LINK:
30394         jj_consume_token(LINK);
30395         break;
30396       case LOCAL:
30397         jj_consume_token(LOCAL);
30398         break;
30399       case LOGOFF:
30400         jj_consume_token(LOGOFF);
30401         break;
30402       case LOGON:
30403         jj_consume_token(LOGON);
30404         break;
30405       case MAP:
30406         jj_consume_token(MAP);
30407         break;
30408       case MAX:
30409         jj_consume_token(MAX);
30410         break;
30411       case MAXLEN:
30412         jj_consume_token(MAXLEN);
30413         break;
30414       case MEMBER:
30415         jj_consume_token(MEMBER);
30416         break;
30417       case MERGE:
30418         jj_consume_token(MERGE);
30419         break;
30420       case MIN:
30421         jj_consume_token(MIN);
30422         break;
30423       case MINUTE:
30424         jj_consume_token(MINUTE);
30425         break;
30426       case MLSLABEL:
30427         jj_consume_token(MLSLABEL);
30428         break;
30429       case MODIFY:
30430         jj_consume_token(MODIFY);
30431         break;
30432       case MONTH:
30433         jj_consume_token(MONTH);
30434         break;
30435       case MULTISET:
30436         jj_consume_token(MULTISET);
30437         break;
30438       case NAME:
30439         jj_consume_token(NAME);
30440         break;
30441       case NATURAL:
30442         jj_consume_token(NATURAL);
30443         break;
30444       case NCHAR:
30445         jj_consume_token(NCHAR);
30446         break;
30447       case NCHAR_CS:
30448         jj_consume_token(NCHAR_CS);
30449         break;
30450       case NCLOB:
30451         jj_consume_token(NCLOB);
30452         break;
30453       case NESTED:
30454         jj_consume_token(NESTED);
30455         break;
30456       case NEW:
30457         jj_consume_token(NEW);
30458         break;
30459       case NO:
30460         jj_consume_token(NO);
30461         break;
30462       case NOAUDIT:
30463         jj_consume_token(NOAUDIT);
30464         break;
30465       case NUMERIC:
30466         jj_consume_token(NUMERIC);
30467         break;
30468       case NVARCHAR2:
30469         jj_consume_token(NVARCHAR2);
30470         break;
30471       case OBJECT:
30472         jj_consume_token(OBJECT);
30473         break;
30474       case OID:
30475         jj_consume_token(OID);
30476         break;
30477       case OLD:
30478         jj_consume_token(OLD);
30479         break;
30480       case OPAQUE:
30481         jj_consume_token(OPAQUE);
30482         break;
30483       case OPEN:
30484         jj_consume_token(OPEN);
30485         break;
30486       case ORGANIZATION:
30487         jj_consume_token(ORGANIZATION);
30488         break;
30489       case OTHERS:
30490         jj_consume_token(OTHERS);
30491         break;
30492       case OVERRIDING:
30493         jj_consume_token(OVERRIDING);
30494         break;
30495       case PACKAGE:
30496         jj_consume_token(PACKAGE);
30497         break;
30498       case PARAMETERS:
30499         jj_consume_token(PARAMETERS);
30500         break;
30501       case PARENT:
30502         jj_consume_token(PARENT);
30503         break;
30504       case PARTITION:
30505         jj_consume_token(PARTITION);
30506         break;
30507       case PRECISION:
30508         jj_consume_token(PRECISION);
30509         break;
30510       case PRESERVE:
30511         jj_consume_token(PRESERVE);
30512         break;
30513       case PRINT:
30514         jj_consume_token(PRINT);
30515         break;
30516       case PROCEDURE:
30517         jj_consume_token(PROCEDURE);
30518         break;
30519       case QUIT:
30520         jj_consume_token(QUIT);
30521         break;
30522       case RANGE:
30523         jj_consume_token(RANGE);
30524         break;
30525       case REAL:
30526         jj_consume_token(REAL);
30527         break;
30528       case RECORD:
30529         jj_consume_token(RECORD);
30530         break;
30531       case REF:
30532         jj_consume_token(REF);
30533         break;
30534       case RELIES_ON:
30535         jj_consume_token(RELIES_ON);
30536         break;
30537       case REMARK:
30538         jj_consume_token(REMARK);
30539         break;
30540       case RESULT:
30541         jj_consume_token(RESULT);
30542         break;
30543       case RETURN:
30544         jj_consume_token(RETURN);
30545         break;
30546       case RETURNING:
30547         jj_consume_token(RETURNING);
30548         break;
30549       case REVERSE:
30550         jj_consume_token(REVERSE);
30551         break;
30552       case RIGHT:
30553         jj_consume_token(RIGHT);
30554         break;
30555       case ROLLBACK:
30556         jj_consume_token(ROLLBACK);
30557         break;
30558       case ROW:
30559         jj_consume_token(ROW);
30560         break;
30561       case ROWID:
30562         jj_consume_token(ROWID);
30563         break;
30564       case ROWNUM:
30565         jj_consume_token(ROWNUM);
30566         break;
30567       case ROWS:
30568         jj_consume_token(ROWS);
30569         break;
30570       case SAVE:
30571         jj_consume_token(SAVE);
30572         break;
30573       case SAVEPOINT:
30574         jj_consume_token(SAVEPOINT);
30575         break;
30576       case SCHEMA:
30577         jj_consume_token(SCHEMA);
30578         break;
30579       case SECOND:
30580         jj_consume_token(SECOND);
30581         break;
30582       case SELF:
30583         jj_consume_token(SELF);
30584         break;
30585       case SERVERERROR:
30586         jj_consume_token(SERVERERROR);
30587         break;
30588       case SESSIONTIMEZONE:
30589         jj_consume_token(SESSIONTIMEZONE);
30590         break;
30591       case SET:
30592         jj_consume_token(SET);
30593         break;
30594       case SHARED:
30595         jj_consume_token(SHARED);
30596         break;
30597       case SHUTDOWN:
30598         jj_consume_token(SHUTDOWN);
30599         break;
30600       case SPACE:
30601         jj_consume_token(SPACE);
30602         break;
30603       case STARTUP:
30604         jj_consume_token(STARTUP);
30605         break;
30606       case STATEMENT:
30607         jj_consume_token(STATEMENT);
30608         break;
30609       case STATIC:
30610         jj_consume_token(STATIC);
30611         break;
30612       case STATISTICS:
30613         jj_consume_token(STATISTICS);
30614         break;
30615       case STRUCT:
30616         jj_consume_token(STRUCT);
30617         break;
30618       case SUBMULTISET:
30619         jj_consume_token(SUBMULTISET);
30620         break;
30621       case SUBSTITUTABLE:
30622         jj_consume_token(SUBSTITUTABLE);
30623         break;
30624       case SUBTYPE:
30625         jj_consume_token(SUBTYPE);
30626         break;
30627       case SUCCESSFUL:
30628         jj_consume_token(SUCCESSFUL);
30629         break;
30630       case SUSPEND:
30631         jj_consume_token(SUSPEND);
30632         break;
30633       case TDO:
30634         jj_consume_token(TDO);
30635         break;
30636       case TEMPORARY:
30637         jj_consume_token(TEMPORARY);
30638         break;
30639       case TIME:
30640         jj_consume_token(TIME);
30641         break;
30642       case TIMESTAMP:
30643         jj_consume_token(TIMESTAMP);
30644         break;
30645       case TIMEZONE_ABBR:
30646         jj_consume_token(TIMEZONE_ABBR);
30647         break;
30648       case TIMEZONE_HOUR:
30649         jj_consume_token(TIMEZONE_HOUR);
30650         break;
30651       case TIMEZONE_MINUTE:
30652         jj_consume_token(TIMEZONE_MINUTE);
30653         break;
30654       case TIMEZONE_REGION:
30655         jj_consume_token(TIMEZONE_REGION);
30656         break;
30657       case TRAILING:
30658         jj_consume_token(TRAILING);
30659         break;
30660       case TRANSACTION:
30661         jj_consume_token(TRANSACTION);
30662         break;
30663       case TREAT:
30664         jj_consume_token(TREAT);
30665         break;
30666       case TRIM:
30667         jj_consume_token(TRIM);
30668         break;
30669       case TRUNCATE:
30670         jj_consume_token(TRUNCATE);
30671         break;
30672       case UNDEFINE:
30673         jj_consume_token(UNDEFINE);
30674         break;
30675       case UNDER:
30676         jj_consume_token(UNDER);
30677         break;
30678       case UROWID:
30679         jj_consume_token(UROWID);
30680         break;
30681       case USER:
30682         jj_consume_token(USER);
30683         break;
30684       case USING:
30685         jj_consume_token(USING);
30686         break;
30687       case VARRAY:
30688         jj_consume_token(VARRAY);
30689         break;
30690       case VARIABLE:
30691         jj_consume_token(VARIABLE);
30692         break;
30693       case VARYING:
30694         jj_consume_token(VARYING);
30695         break;
30696       case WHENEVER:
30697         jj_consume_token(WHENEVER);
30698         break;
30699       case YEAR:
30700         jj_consume_token(YEAR);
30701         break;
30702       case YES:
30703         jj_consume_token(YES);
30704         break;
30705       case ZONE:
30706         jj_consume_token(ZONE);
30707         break;
30708       case SHOW:
30709         jj_consume_token(SHOW);
30710         break;
30711       case WRAPPED:
30712         jj_consume_token(WRAPPED);
30713         break;
30714       case SYS_REFCURSOR:
30715         jj_consume_token(SYS_REFCURSOR);
30716         break;
30717       case EDITIONABLE:
30718         jj_consume_token(EDITIONABLE);
30719         break;
30720       case NONEDITIONABLE:
30721         jj_consume_token(NONEDITIONABLE);
30722         break;
30723       case ACCESSIBLE:
30724         jj_consume_token(ACCESSIBLE);
30725         break;
30726       case NULLIF:
30727         jj_consume_token(NULLIF);
30728         break;
30729       case RENAME:
30730         jj_consume_token(RENAME);
30731         break;
30732       case RELEASE:
30733         jj_consume_token(RELEASE);
30734         break;
30735       case INLINE:
30736         jj_consume_token(INLINE);
30737         break;
30738       default:
30739         jj_la1[452] = jj_gen;
30740         jj_consume_token(-1);
30741         throw new ParseException();
30742       }
30743   jjtree.closeNodeScope(jjtn000, true);
30744   jjtc000 = false;
30745   jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30746     } finally {
30747   if (jjtc000) {
30748     jjtree.closeNodeScope(jjtn000, true);
30749   }
30750     }
30751     throw new Error("Missing return statement in function");
30752   }
30753 
30754 //SRT 2011-04-17 - END  */
30755 /**
30756  * 2006-05-20 - Matthias Hendler - added <OLD> and <PARENT>  
30757  */
30758   final public ASTID ID() throws ParseException {
30759              /*@bgen(jjtree) ID */
30760   ASTID jjtn000 = new ASTID(this, JJTID);
30761   boolean jjtc000 = true;
30762   jjtree.openNodeScope(jjtn000);
30763     try {
30764       switch (jj_nt.kind) {
30765       case IDENTIFIER:
30766         jj_consume_token(IDENTIFIER);
30767         break;
30768       case QUOTED_LITERAL:
30769         jj_consume_token(QUOTED_LITERAL);
30770         break;
30771       case DEFINER:
30772       case CURRENT_USER:
30773       case LANGUAGE:
30774       case INLINE:
30775       case ADD:
30776       case AGGREGATE:
30777       case AT:
30778       case ATTRIBUTE:
30779       case AUTHID:
30780       case BULK:
30781       case BYTE:
30782       case CASCADE:
30783       case CLOSE:
30784       case COALESCE:
30785       case COLLECT:
30786       case COLUMN:
30787       case COMMENT:
30788       case COMMIT:
30789       case CONSTRUCTOR:
30790       case CONTINUE:
30791       case CONVERT:
30792       case CURRENT:
30793       case CURSOR:
30794       case DATA:
30795       case DAY:
30796       case DISABLE:
30797       case EDITIONABLE:
30798       case ELEMENT:
30799       case ENABLE:
30800       case ESCAPE:
30801       case EXCEPT:
30802       case EXCEPTIONS:
30803       case EXIT:
30804       case EXTERNAL:
30805       case EXTENDS:
30806       case EXTRACT:
30807       case FALSE:
30808       case FINAL:
30809       case FORCE:
30810       case FUNCTION:
30811       case GLOBAL:
30812       case HASH:
30813       case HEAP:
30814       case HOUR:
30815       case IMMEDIATE:
30816       case INDICES:
30817       case INDEXTYPE:
30818       case INDICATOR:
30819       case INSTANTIABLE:
30820       case INTERVAL:
30821       case INVALIDATE:
30822       case ISOLATION:
30823       case JAVA:
30824       case LEVEL:
30825       case LIMIT:
30826       case MAP:
30827       case MAX:
30828       case MEMBER:
30829       case MERGE:
30830       case MIN:
30831       case MINUTE:
30832       case MLSLABEL:
30833       case MODIFY:
30834       case MONTH:
30835       case NATURAL:
30836       case NEW:
30837       case NO:
30838       case NONEDITIONABLE:
30839       case NULLIF:
30840       case OBJECT:
30841       case OID:
30842       case OPAQUE:
30843       case OPEN:
30844       case ORGANIZATION:
30845       case OTHERS:
30846       case OVERRIDING:
30847       case PACKAGE:
30848       case PARTITION:
30849       case PRESERVE:
30850       case PROCEDURE:
30851       case RANGE:
30852       case REAL:
30853       case RECORD:
30854       case REF:
30855       case RELEASE:
30856       case RELIES_ON:
30857       case RENAME:
30858       case RESULT:
30859       case RETURN:
30860       case RETURNING:
30861       case REVERSE:
30862       case ROLLBACK:
30863       case ROW:
30864       case ROWS:
30865       case ROWID:
30866       case ROWNUM:
30867       case SAVE:
30868       case SAVEPOINT:
30869       case SECOND:
30870       case SELF:
30871       case SET:
30872       case SPACE:
30873       case STATIC:
30874       case SUBTYPE:
30875       case SUBSTITUTABLE:
30876       case SUCCESSFUL:
30877       case SYS_REFCURSOR:
30878       case TEMPORARY:
30879       case TIME:
30880       case TIMESTAMP:
30881       case TIMEZONE_REGION:
30882       case TIMEZONE_ABBR:
30883       case TIMEZONE_MINUTE:
30884       case TIMEZONE_HOUR:
30885       case TRANSACTION:
30886       case TRUE:
30887       case UNDER:
30888       case USING:
30889       case YES:
30890       case SHOW:
30891       case A:
30892       case DOUBLE:
30893       case DEC:
30894       case PRECISION:
30895       case NUMERIC:
30896       case NCHAR:
30897       case NVARCHAR2:
30898       case UROWID:
30899       case VARRAY:
30900       case VARYING:
30901       case BFILE:
30902       case BLOB:
30903       case CLOB:
30904       case NCLOB:
30905       case YEAR:
30906       case LOCAL:
30907       case ZONE:
30908       case CHARACTER:
30909       case AFTER:
30910       case BEFORE:
30911       case OLD:
30912       case PARENT:
30913       case ANALYZE:
30914       case ASSOCIATE:
30915       case AUDIT:
30916       case COMPOUND:
30917       case DATABASE:
30918       case CALL:
30919       case DDL:
30920       case DISASSOCIATE:
30921       case EACH:
30922       case FOLLOWS:
30923       case LOGOFF:
30924       case LOGON:
30925       case NESTED:
30926       case NOAUDIT:
30927       case SCHEMA:
30928       case SERVERERROR:
30929       case SHUTDOWN:
30930       case STARTUP:
30931       case STATEMENT:
30932       case STATISTICS:
30933       case SUSPEND:
30934       case TRUNCATE:
30935       case WRAPPED:
30936       case LIBRARY:
30937       case NAME:
30938       case STRUCT:
30939       case CONTEXT:
30940       case PARAMETERS:
30941       case LENGTH:
30942       case TDO:
30943       case MAXLEN:
30944       case CHARSETID:
30945       case CHARSETFORM:
30946       case ACCEPT:
30947       case ACCESSIBLE:
30948       case COPY:
30949       case DEFINE:
30950       case DISCONNECT:
30951       case HOST:
30952       case PRINT:
30953       case QUIT:
30954       case REMARK:
30955       case UNDEFINE:
30956       case VARIABLE:
30957       case WHENEVER:
30958       case ATTACH:
30959       case CAST:
30960       case TREAT:
30961       case TRIM:
30962       case LEFT:
30963       case RIGHT:
30964       case BOTH:
30965       case EMPTY:
30966       case MULTISET:
30967       case SUBMULTISET:
30968       case LEADING:
30969       case TRAILING:
30970       case CHAR_CS:
30971       case NCHAR_CS:
30972       case DBTIMEZONE:
30973       case SESSIONTIMEZONE:
30974       case AUTHENTICATED:
30975       case LINK:
30976       case SHARED:
30977       case DIRECTORY:
30978       case USER:
30979         KEYWORD_UNRESERVED();
30980         break;
30981       case REPLACE:
30982         jj_consume_token(REPLACE);
30983         break;
30984       case SERIALLY_REUSABLE:
30985         jj_consume_token(SERIALLY_REUSABLE);
30986         break;
30987       case RESTRICT_REFERENCES:
30988         jj_consume_token(RESTRICT_REFERENCES);
30989         break;
30990       case EXCEPTION_INIT:
30991         jj_consume_token(EXCEPTION_INIT);
30992         break;
30993       case AUTONOMOUS_TRANSACTION:
30994         jj_consume_token(AUTONOMOUS_TRANSACTION);
30995         break;
30996       case ALL:
30997         jj_consume_token(ALL);
30998         break;
30999       case ALTER:
31000         jj_consume_token(ALTER);
31001         break;
31002       case AND:
31003         jj_consume_token(AND);
31004         break;
31005       case ANY:
31006         jj_consume_token(ANY);
31007         break;
31008       case ARRAY:
31009         jj_consume_token(ARRAY);
31010         break;
31011       case AS:
31012         jj_consume_token(AS);
31013         break;
31014       case ASC:
31015         jj_consume_token(ASC);
31016         break;
31017       case AVG:
31018         jj_consume_token(AVG);
31019         break;
31020       case BETWEEN:
31021         jj_consume_token(BETWEEN);
31022         break;
31023       case BINARY_INTEGER:
31024         jj_consume_token(BINARY_INTEGER);
31025         break;
31026       case BODY:
31027         jj_consume_token(BODY);
31028         break;
31029       case BOOLEAN:
31030         jj_consume_token(BOOLEAN);
31031         break;
31032       case BY:
31033         jj_consume_token(BY);
31034         break;
31035       case CASE:
31036         jj_consume_token(CASE);
31037         break;
31038       case CHAR:
31039         jj_consume_token(CHAR);
31040         break;
31041       case CHAR_BASE:
31042         jj_consume_token(CHAR_BASE);
31043         break;
31044       case CHECK:
31045         jj_consume_token(CHECK);
31046         break;
31047       case CLUSTER:
31048         jj_consume_token(CLUSTER);
31049         break;
31050       case COMPRESS:
31051         jj_consume_token(COMPRESS);
31052         break;
31053       case CONNECT:
31054         jj_consume_token(CONNECT);
31055         break;
31056       case CONSTANT:
31057         jj_consume_token(CONSTANT);
31058         break;
31059       case CREATE:
31060         jj_consume_token(CREATE);
31061         break;
31062       case CURRVAL:
31063         jj_consume_token(CURRVAL);
31064         break;
31065       case DATE:
31066         jj_consume_token(DATE);
31067         break;
31068       case DECLARE:
31069         jj_consume_token(DECLARE);
31070         break;
31071       case DECIMAL:
31072         jj_consume_token(DECIMAL);
31073         break;
31074       case _DEFAULT:
31075         jj_consume_token(_DEFAULT);
31076         break;
31077       case DELETE:
31078         jj_consume_token(DELETE);
31079         break;
31080       case DESC:
31081         jj_consume_token(DESC);
31082         break;
31083       case DISTINCT:
31084         jj_consume_token(DISTINCT);
31085         break;
31086       case DO:
31087         jj_consume_token(DO);
31088         break;
31089       case DROP:
31090         jj_consume_token(DROP);
31091         break;
31092       case ELSE:
31093         jj_consume_token(ELSE);
31094         break;
31095       case ELSIF:
31096         jj_consume_token(ELSIF);
31097         break;
31098       case EXCEPTION:
31099         jj_consume_token(EXCEPTION);
31100         break;
31101       case EXCLUSIVE:
31102         jj_consume_token(EXCLUSIVE);
31103         break;
31104       case EXECUTE:
31105         jj_consume_token(EXECUTE);
31106         break;
31107       case EXISTS:
31108         jj_consume_token(EXISTS);
31109         break;
31110       case FETCH:
31111         jj_consume_token(FETCH);
31112         break;
31113       case FLOAT:
31114         jj_consume_token(FLOAT);
31115         break;
31116       case FOR:
31117         jj_consume_token(FOR);
31118         break;
31119       case FORALL:
31120         jj_consume_token(FORALL);
31121         break;
31122       case FROM:
31123         jj_consume_token(FROM);
31124         break;
31125       case GOTO:
31126         jj_consume_token(GOTO);
31127         break;
31128       case GROUP:
31129         jj_consume_token(GROUP);
31130         break;
31131       case HAVING:
31132         jj_consume_token(HAVING);
31133         break;
31134       case IF:
31135         jj_consume_token(IF);
31136         break;
31137       case IN:
31138         jj_consume_token(IN);
31139         break;
31140       case INDEX:
31141         jj_consume_token(INDEX);
31142         break;
31143       case INSERT:
31144         jj_consume_token(INSERT);
31145         break;
31146       case INTEGER:
31147         jj_consume_token(INTEGER);
31148         break;
31149       case INTERFACE:
31150         jj_consume_token(INTERFACE);
31151         break;
31152       case INTERSECT:
31153         jj_consume_token(INTERSECT);
31154         break;
31155       case INTO:
31156         jj_consume_token(INTO);
31157         break;
31158       case IS:
31159         jj_consume_token(IS);
31160         break;
31161       case LIKE:
31162         jj_consume_token(LIKE);
31163         break;
31164       case LIMITED:
31165         jj_consume_token(LIMITED);
31166         break;
31167       case LOCK:
31168         jj_consume_token(LOCK);
31169         break;
31170       case LONG:
31171         jj_consume_token(LONG);
31172         break;
31173       case LOOP:
31174         jj_consume_token(LOOP);
31175         break;
31176       case MINUS:
31177         jj_consume_token(MINUS);
31178         break;
31179       case MOD:
31180         jj_consume_token(MOD);
31181         break;
31182       case MODE:
31183         jj_consume_token(MODE);
31184         break;
31185       case NATURALN:
31186         jj_consume_token(NATURALN);
31187         break;
31188       case NEXTVAL:
31189         jj_consume_token(NEXTVAL);
31190         break;
31191       case NOCOPY:
31192         jj_consume_token(NOCOPY);
31193         break;
31194       case NOT:
31195         jj_consume_token(NOT);
31196         break;
31197       case NOWAIT:
31198         jj_consume_token(NOWAIT);
31199         break;
31200       case NULL:
31201         jj_consume_token(NULL);
31202         break;
31203       case NUMBER:
31204         jj_consume_token(NUMBER);
31205         break;
31206       case NUMBER_BASE:
31207         jj_consume_token(NUMBER_BASE);
31208         break;
31209       case OCIROWID:
31210         jj_consume_token(OCIROWID);
31211         break;
31212       case OF:
31213         jj_consume_token(OF);
31214         break;
31215       case ON:
31216         jj_consume_token(ON);
31217         break;
31218       case BFILE_BASE:
31219         jj_consume_token(BFILE_BASE);
31220         break;
31221       case BLOB_BASE:
31222         jj_consume_token(BLOB_BASE);
31223         break;
31224       case CLOB_BASE:
31225         jj_consume_token(CLOB_BASE);
31226         break;
31227       case DATE_BASE:
31228         jj_consume_token(DATE_BASE);
31229         break;
31230       case OPERATOR:
31231         jj_consume_token(OPERATOR);
31232         break;
31233       case OPTION:
31234         jj_consume_token(OPTION);
31235         break;
31236       case OR:
31237         jj_consume_token(OR);
31238         break;
31239       case ORDER:
31240         jj_consume_token(ORDER);
31241         break;
31242       case OUT:
31243         jj_consume_token(OUT);
31244         break;
31245       case PCTFREE:
31246         jj_consume_token(PCTFREE);
31247         break;
31248       case PLS_INTEGER:
31249         jj_consume_token(PLS_INTEGER);
31250         break;
31251       case POSITIVE:
31252         jj_consume_token(POSITIVE);
31253         break;
31254       case POSITIVEN:
31255         jj_consume_token(POSITIVEN);
31256         break;
31257       case PRIOR:
31258         jj_consume_token(PRIOR);
31259         break;
31260       case PRIVATE:
31261         jj_consume_token(PRIVATE);
31262         break;
31263       case PROMPT:
31264         jj_consume_token(PROMPT);
31265         break;
31266       case PUBLIC:
31267         jj_consume_token(PUBLIC);
31268         break;
31269       case RAISE:
31270         jj_consume_token(RAISE);
31271         break;
31272       case RAW:
31273         jj_consume_token(RAW);
31274         break;
31275       case ROWTYPE:
31276         jj_consume_token(ROWTYPE);
31277         break;
31278       case SELECT:
31279         jj_consume_token(SELECT);
31280         break;
31281       case SEPARATE:
31282         jj_consume_token(SEPARATE);
31283         break;
31284       case SHARE:
31285         jj_consume_token(SHARE);
31286         break;
31287       case SMALLINT:
31288         jj_consume_token(SMALLINT);
31289         break;
31290       case SQL:
31291         jj_consume_token(SQL);
31292         break;
31293       case SQLCODE:
31294         jj_consume_token(SQLCODE);
31295         break;
31296       case SQLERRM:
31297         jj_consume_token(SQLERRM);
31298         break;
31299       case START:
31300         jj_consume_token(START);
31301         break;
31302       case STDDEV:
31303         jj_consume_token(STDDEV);
31304         break;
31305       case SUM:
31306         jj_consume_token(SUM);
31307         break;
31308       case SYNONYM:
31309         jj_consume_token(SYNONYM);
31310         break;
31311       case SYSDATE:
31312         jj_consume_token(SYSDATE);
31313         break;
31314       case TABLE:
31315         jj_consume_token(TABLE);
31316         break;
31317       case THEN:
31318         jj_consume_token(THEN);
31319         break;
31320       case TO:
31321         jj_consume_token(TO);
31322         break;
31323       case TRIGGER:
31324         jj_consume_token(TRIGGER);
31325         break;
31326       case TYPE:
31327         jj_consume_token(TYPE);
31328         break;
31329       case UI:
31330         jj_consume_token(UI);
31331         break;
31332       case UPDATE:
31333         jj_consume_token(UPDATE);
31334         break;
31335       case VARCHAR:
31336         jj_consume_token(VARCHAR);
31337         break;
31338       case VARCHAR2:
31339         jj_consume_token(VARCHAR2);
31340         break;
31341       case INT:
31342         jj_consume_token(INT);
31343         break;
31344       case SIGNTYPE:
31345         jj_consume_token(SIGNTYPE);
31346         break;
31347       case STRING:
31348         jj_consume_token(STRING);
31349         break;
31350       case WITH:
31351         jj_consume_token(WITH);
31352         break;
31353       case WHILE:
31354         jj_consume_token(WHILE);
31355         break;
31356       case JAVA_INTERFACE_CLASS:
31357         jj_consume_token(JAVA_INTERFACE_CLASS);
31358         break;
31359       case SQLDATA_CLASS:
31360         jj_consume_token(SQLDATA_CLASS);
31361         break;
31362       case CUSTOMDATUM_CLASS:
31363         jj_consume_token(CUSTOMDATUM_CLASS);
31364         break;
31365       case ORADATA_CLASS:
31366         jj_consume_token(ORADATA_CLASS);
31367         break;
31368       default:
31369         jj_la1[453] = jj_gen;
31370         jj_consume_token(-1);
31371         throw new ParseException();
31372       }
31373           jjtree.closeNodeScope(jjtn000, true);
31374           jjtc000 = false;
31375           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31376     } catch (Throwable jjte000) {
31377           if (jjtc000) {
31378             jjtree.clearNodeScope(jjtn000);
31379             jjtc000 = false;
31380           } else {
31381             jjtree.popNode();
31382           }
31383           if (jjte000 instanceof RuntimeException) {
31384             {if (true) throw (RuntimeException)jjte000;}
31385           }
31386           if (jjte000 instanceof ParseException) {
31387             {if (true) throw (ParseException)jjte000;}
31388           }
31389           {if (true) throw (Error)jjte000;}
31390     } finally {
31391           if (jjtc000) {
31392             jjtree.closeNodeScope(jjtn000, true);
31393           }
31394     }
31395     throw new Error("Missing return statement in function");
31396   }
31397 
31398 /**
31399  * 2006-05-20 - Matthias Hendler - added <OLD>, <NEW>, <LOOP>, <INT>
31400  */
31401   final public ASTUnqualifiedID UnqualifiedID() throws ParseException {
31402                                    /*@bgen(jjtree) UnqualifiedID */
31403   ASTUnqualifiedID jjtn000 = new ASTUnqualifiedID(this, JJTUNQUALIFIEDID);
31404   boolean jjtc000 = true;
31405   jjtree.openNodeScope(jjtn000);
31406     try {
31407       switch (jj_nt.kind) {
31408       case IDENTIFIER:
31409         jj_consume_token(IDENTIFIER);
31410         break;
31411       case QUOTED_LITERAL:
31412         jj_consume_token(QUOTED_LITERAL);
31413         break;
31414       case DEFINER:
31415       case CURRENT_USER:
31416       case LANGUAGE:
31417       case INLINE:
31418       case ADD:
31419       case AGGREGATE:
31420       case AT:
31421       case ATTRIBUTE:
31422       case AUTHID:
31423       case BULK:
31424       case BYTE:
31425       case CASCADE:
31426       case CLOSE:
31427       case COALESCE:
31428       case COLLECT:
31429       case COLUMN:
31430       case COMMENT:
31431       case COMMIT:
31432       case CONSTRUCTOR:
31433       case CONTINUE:
31434       case CONVERT:
31435       case CURRENT:
31436       case CURSOR:
31437       case DATA:
31438       case DAY:
31439       case DISABLE:
31440       case EDITIONABLE:
31441       case ELEMENT:
31442       case ENABLE:
31443       case ESCAPE:
31444       case EXCEPT:
31445       case EXCEPTIONS:
31446       case EXIT:
31447       case EXTERNAL:
31448       case EXTENDS:
31449       case EXTRACT:
31450       case FALSE:
31451       case FINAL:
31452       case FORCE:
31453       case FUNCTION:
31454       case GLOBAL:
31455       case HASH:
31456       case HEAP:
31457       case HOUR:
31458       case IMMEDIATE:
31459       case INDICES:
31460       case INDEXTYPE:
31461       case INDICATOR:
31462       case INSTANTIABLE:
31463       case INTERVAL:
31464       case INVALIDATE:
31465       case ISOLATION:
31466       case JAVA:
31467       case LEVEL:
31468       case LIMIT:
31469       case MAP:
31470       case MAX:
31471       case MEMBER:
31472       case MERGE:
31473       case MIN:
31474       case MINUTE:
31475       case MLSLABEL:
31476       case MODIFY:
31477       case MONTH:
31478       case NATURAL:
31479       case NEW:
31480       case NO:
31481       case NONEDITIONABLE:
31482       case NULLIF:
31483       case OBJECT:
31484       case OID:
31485       case OPAQUE:
31486       case OPEN:
31487       case ORGANIZATION:
31488       case OTHERS:
31489       case OVERRIDING:
31490       case PACKAGE:
31491       case PARTITION:
31492       case PRESERVE:
31493       case PROCEDURE:
31494       case RANGE:
31495       case REAL:
31496       case RECORD:
31497       case REF:
31498       case RELEASE:
31499       case RELIES_ON:
31500       case RENAME:
31501       case RESULT:
31502       case RETURN:
31503       case RETURNING:
31504       case REVERSE:
31505       case ROLLBACK:
31506       case ROW:
31507       case ROWS:
31508       case ROWID:
31509       case ROWNUM:
31510       case SAVE:
31511       case SAVEPOINT:
31512       case SECOND:
31513       case SELF:
31514       case SET:
31515       case SPACE:
31516       case STATIC:
31517       case SUBTYPE:
31518       case SUBSTITUTABLE:
31519       case SUCCESSFUL:
31520       case SYS_REFCURSOR:
31521       case TEMPORARY:
31522       case TIME:
31523       case TIMESTAMP:
31524       case TIMEZONE_REGION:
31525       case TIMEZONE_ABBR:
31526       case TIMEZONE_MINUTE:
31527       case TIMEZONE_HOUR:
31528       case TRANSACTION:
31529       case TRUE:
31530       case UNDER:
31531       case USING:
31532       case YES:
31533       case SHOW:
31534       case A:
31535       case DOUBLE:
31536       case DEC:
31537       case PRECISION:
31538       case NUMERIC:
31539       case NCHAR:
31540       case NVARCHAR2:
31541       case UROWID:
31542       case VARRAY:
31543       case VARYING:
31544       case BFILE:
31545       case BLOB:
31546       case CLOB:
31547       case NCLOB:
31548       case YEAR:
31549       case LOCAL:
31550       case ZONE:
31551       case CHARACTER:
31552       case AFTER:
31553       case BEFORE:
31554       case OLD:
31555       case PARENT:
31556       case ANALYZE:
31557       case ASSOCIATE:
31558       case AUDIT:
31559       case COMPOUND:
31560       case DATABASE:
31561       case CALL:
31562       case DDL:
31563       case DISASSOCIATE:
31564       case EACH:
31565       case FOLLOWS:
31566       case LOGOFF:
31567       case LOGON:
31568       case NESTED:
31569       case NOAUDIT:
31570       case SCHEMA:
31571       case SERVERERROR:
31572       case SHUTDOWN:
31573       case STARTUP:
31574       case STATEMENT:
31575       case STATISTICS:
31576       case SUSPEND:
31577       case TRUNCATE:
31578       case WRAPPED:
31579       case LIBRARY:
31580       case NAME:
31581       case STRUCT:
31582       case CONTEXT:
31583       case PARAMETERS:
31584       case LENGTH:
31585       case TDO:
31586       case MAXLEN:
31587       case CHARSETID:
31588       case CHARSETFORM:
31589       case ACCEPT:
31590       case ACCESSIBLE:
31591       case COPY:
31592       case DEFINE:
31593       case DISCONNECT:
31594       case HOST:
31595       case PRINT:
31596       case QUIT:
31597       case REMARK:
31598       case UNDEFINE:
31599       case VARIABLE:
31600       case WHENEVER:
31601       case ATTACH:
31602       case CAST:
31603       case TREAT:
31604       case TRIM:
31605       case LEFT:
31606       case RIGHT:
31607       case BOTH:
31608       case EMPTY:
31609       case MULTISET:
31610       case SUBMULTISET:
31611       case LEADING:
31612       case TRAILING:
31613       case CHAR_CS:
31614       case NCHAR_CS:
31615       case DBTIMEZONE:
31616       case SESSIONTIMEZONE:
31617       case AUTHENTICATED:
31618       case LINK:
31619       case SHARED:
31620       case DIRECTORY:
31621       case USER:
31622         KEYWORD_UNRESERVED();
31623         break;
31624       case BODY:
31625         jj_consume_token(BODY);
31626         break;
31627       case MOD:
31628         jj_consume_token(MOD);
31629         break;
31630       case OPERATOR:
31631         jj_consume_token(OPERATOR);
31632         break;
31633       case PRIVATE:
31634         jj_consume_token(PRIVATE);
31635         break;
31636       case RAW:
31637         jj_consume_token(RAW);
31638         break;
31639       case REPLACE:
31640         jj_consume_token(REPLACE);
31641         break;
31642       case STRING:
31643         jj_consume_token(STRING);
31644         break;
31645       case SQL:
31646         jj_consume_token(SQL);
31647         break;
31648       case SQLCODE:
31649         jj_consume_token(SQLCODE);
31650         break;
31651       case SQLERRM:
31652         jj_consume_token(SQLERRM);
31653         break;
31654       case SYSDATE:
31655         jj_consume_token(SYSDATE);
31656         break;
31657       case TYPE:
31658         jj_consume_token(TYPE);
31659         break;
31660       case LOOP:
31661         jj_consume_token(LOOP);
31662         break;
31663       case INT:
31664         jj_consume_token(INT);
31665         break;
31666       case ARRAY:
31667         jj_consume_token(ARRAY);
31668         break;
31669       default:
31670         jj_la1[454] = jj_gen;
31671         jj_consume_token(-1);
31672         throw new ParseException();
31673       }
31674           jjtree.closeNodeScope(jjtn000, true);
31675           jjtc000 = false;
31676           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31677     } catch (Throwable jjte000) {
31678           if (jjtc000) {
31679             jjtree.clearNodeScope(jjtn000);
31680             jjtc000 = false;
31681           } else {
31682             jjtree.popNode();
31683           }
31684           if (jjte000 instanceof RuntimeException) {
31685             {if (true) throw (RuntimeException)jjte000;}
31686           }
31687           if (jjte000 instanceof ParseException) {
31688             {if (true) throw (ParseException)jjte000;}
31689           }
31690           {if (true) throw (Error)jjte000;}
31691     } finally {
31692           if (jjtc000) {
31693             jjtree.closeNodeScope(jjtn000, true);
31694           }
31695     }
31696     throw new Error("Missing return statement in function");
31697   }
31698 
31699 /**
31700  * 2006-05-20 - Matthias Hendler - added <LIMIT>
31701  */
31702   final public ASTQualifiedID QualifiedID() throws ParseException {
31703                                /*@bgen(jjtree) QualifiedID */
31704   ASTQualifiedID jjtn000 = new ASTQualifiedID(this, JJTQUALIFIEDID);
31705   boolean jjtc000 = true;
31706   jjtree.openNodeScope(jjtn000);
31707     try {
31708       switch (jj_nt.kind) {
31709       case IDENTIFIER:
31710         jj_consume_token(IDENTIFIER);
31711         break;
31712       case QUOTED_LITERAL:
31713         jj_consume_token(QUOTED_LITERAL);
31714         break;
31715       case DEFINER:
31716       case CURRENT_USER:
31717       case LANGUAGE:
31718       case INLINE:
31719       case ADD:
31720       case AGGREGATE:
31721       case AT:
31722       case ATTRIBUTE:
31723       case AUTHID:
31724       case BULK:
31725       case BYTE:
31726       case CASCADE:
31727       case CLOSE:
31728       case COALESCE:
31729       case COLLECT:
31730       case COLUMN:
31731       case COMMENT:
31732       case COMMIT:
31733       case CONSTRUCTOR:
31734       case CONTINUE:
31735       case CONVERT:
31736       case CURRENT:
31737       case CURSOR:
31738       case DATA:
31739       case DAY:
31740       case DISABLE:
31741       case EDITIONABLE:
31742       case ELEMENT:
31743       case ENABLE:
31744       case ESCAPE:
31745       case EXCEPT:
31746       case EXCEPTIONS:
31747       case EXIT:
31748       case EXTERNAL:
31749       case EXTENDS:
31750       case EXTRACT:
31751       case FALSE:
31752       case FINAL:
31753       case FORCE:
31754       case FUNCTION:
31755       case GLOBAL:
31756       case HASH:
31757       case HEAP:
31758       case HOUR:
31759       case IMMEDIATE:
31760       case INDICES:
31761       case INDEXTYPE:
31762       case INDICATOR:
31763       case INSTANTIABLE:
31764       case INTERVAL:
31765       case INVALIDATE:
31766       case ISOLATION:
31767       case JAVA:
31768       case LEVEL:
31769       case LIMIT:
31770       case MAP:
31771       case MAX:
31772       case MEMBER:
31773       case MERGE:
31774       case MIN:
31775       case MINUTE:
31776       case MLSLABEL:
31777       case MODIFY:
31778       case MONTH:
31779       case NATURAL:
31780       case NEW:
31781       case NO:
31782       case NONEDITIONABLE:
31783       case NULLIF:
31784       case OBJECT:
31785       case OID:
31786       case OPAQUE:
31787       case OPEN:
31788       case ORGANIZATION:
31789       case OTHERS:
31790       case OVERRIDING:
31791       case PACKAGE:
31792       case PARTITION:
31793       case PRESERVE:
31794       case PROCEDURE:
31795       case RANGE:
31796       case REAL:
31797       case RECORD:
31798       case REF:
31799       case RELEASE:
31800       case RELIES_ON:
31801       case RENAME:
31802       case RESULT:
31803       case RETURN:
31804       case RETURNING:
31805       case REVERSE:
31806       case ROLLBACK:
31807       case ROW:
31808       case ROWS:
31809       case ROWID:
31810       case ROWNUM:
31811       case SAVE:
31812       case SAVEPOINT:
31813       case SECOND:
31814       case SELF:
31815       case SET:
31816       case SPACE:
31817       case STATIC:
31818       case SUBTYPE:
31819       case SUBSTITUTABLE:
31820       case SUCCESSFUL:
31821       case SYS_REFCURSOR:
31822       case TEMPORARY:
31823       case TIME:
31824       case TIMESTAMP:
31825       case TIMEZONE_REGION:
31826       case TIMEZONE_ABBR:
31827       case TIMEZONE_MINUTE:
31828       case TIMEZONE_HOUR:
31829       case TRANSACTION:
31830       case TRUE:
31831       case UNDER:
31832       case USING:
31833       case YES:
31834       case SHOW:
31835       case A:
31836       case DOUBLE:
31837       case DEC:
31838       case PRECISION:
31839       case NUMERIC:
31840       case NCHAR:
31841       case NVARCHAR2:
31842       case UROWID:
31843       case VARRAY:
31844       case VARYING:
31845       case BFILE:
31846       case BLOB:
31847       case CLOB:
31848       case NCLOB:
31849       case YEAR:
31850       case LOCAL:
31851       case ZONE:
31852       case CHARACTER:
31853       case AFTER:
31854       case BEFORE:
31855       case OLD:
31856       case PARENT:
31857       case ANALYZE:
31858       case ASSOCIATE:
31859       case AUDIT:
31860       case COMPOUND:
31861       case DATABASE:
31862       case CALL:
31863       case DDL:
31864       case DISASSOCIATE:
31865       case EACH:
31866       case FOLLOWS:
31867       case LOGOFF:
31868       case LOGON:
31869       case NESTED:
31870       case NOAUDIT:
31871       case SCHEMA:
31872       case SERVERERROR:
31873       case SHUTDOWN:
31874       case STARTUP:
31875       case STATEMENT:
31876       case STATISTICS:
31877       case SUSPEND:
31878       case TRUNCATE:
31879       case WRAPPED:
31880       case LIBRARY:
31881       case NAME:
31882       case STRUCT:
31883       case CONTEXT:
31884       case PARAMETERS:
31885       case LENGTH:
31886       case TDO:
31887       case MAXLEN:
31888       case CHARSETID:
31889       case CHARSETFORM:
31890       case ACCEPT:
31891       case ACCESSIBLE:
31892       case COPY:
31893       case DEFINE:
31894       case DISCONNECT:
31895       case HOST:
31896       case PRINT:
31897       case QUIT:
31898       case REMARK:
31899       case UNDEFINE:
31900       case VARIABLE:
31901       case WHENEVER:
31902       case ATTACH:
31903       case CAST:
31904       case TREAT:
31905       case TRIM:
31906       case LEFT:
31907       case RIGHT:
31908       case BOTH:
31909       case EMPTY:
31910       case MULTISET:
31911       case SUBMULTISET:
31912       case LEADING:
31913       case TRAILING:
31914       case CHAR_CS:
31915       case NCHAR_CS:
31916       case DBTIMEZONE:
31917       case SESSIONTIMEZONE:
31918       case AUTHENTICATED:
31919       case LINK:
31920       case SHARED:
31921       case DIRECTORY:
31922       case USER:
31923         KEYWORD_UNRESERVED();
31924         break;
31925       case REPLACE:
31926         jj_consume_token(REPLACE);
31927         break;
31928       case SERIALLY_REUSABLE:
31929         jj_consume_token(SERIALLY_REUSABLE);
31930         break;
31931       case RESTRICT_REFERENCES:
31932         jj_consume_token(RESTRICT_REFERENCES);
31933         break;
31934       case EXCEPTION_INIT:
31935         jj_consume_token(EXCEPTION_INIT);
31936         break;
31937       case AUTONOMOUS_TRANSACTION:
31938         jj_consume_token(AUTONOMOUS_TRANSACTION);
31939         break;
31940       case ARRAY:
31941         jj_consume_token(ARRAY);
31942         break;
31943       case AVG:
31944         jj_consume_token(AVG);
31945         break;
31946       case BINARY_INTEGER:
31947         jj_consume_token(BINARY_INTEGER);
31948         break;
31949       case BODY:
31950         jj_consume_token(BODY);
31951         break;
31952       case BOOLEAN:
31953         jj_consume_token(BOOLEAN);
31954         break;
31955       case CHAR:
31956         jj_consume_token(CHAR);
31957         break;
31958       case CHAR_BASE:
31959         jj_consume_token(CHAR_BASE);
31960         break;
31961       case CONSTANT:
31962         jj_consume_token(CONSTANT);
31963         break;
31964       case CURRVAL:
31965         jj_consume_token(CURRVAL);
31966         break;
31967       case DATE:
31968         jj_consume_token(DATE);
31969         break;
31970       case DECIMAL:
31971         jj_consume_token(DECIMAL);
31972         break;
31973       case DELETE:
31974         jj_consume_token(DELETE);
31975         break;
31976       case DO:
31977         jj_consume_token(DO);
31978         break;
31979       case ELSIF:
31980         jj_consume_token(ELSIF);
31981         break;
31982       case EXECUTE:
31983         jj_consume_token(EXECUTE);
31984         break;
31985       case EXISTS:
31986         jj_consume_token(EXISTS);
31987         break;
31988       case FLOAT:
31989         jj_consume_token(FLOAT);
31990         break;
31991       case FORALL:
31992         jj_consume_token(FORALL);
31993         break;
31994       case INTEGER:
31995         jj_consume_token(INTEGER);
31996         break;
31997       case INTERFACE:
31998         jj_consume_token(INTERFACE);
31999         break;
32000       case LONG:
32001         jj_consume_token(LONG);
32002         break;
32003       case LOOP:
32004         jj_consume_token(LOOP);
32005         break;
32006       case MOD:
32007         jj_consume_token(MOD);
32008         break;
32009       case NATURALN:
32010         jj_consume_token(NATURALN);
32011         break;
32012       case NEXTVAL:
32013         jj_consume_token(NEXTVAL);
32014         break;
32015       case NOCOPY:
32016         jj_consume_token(NOCOPY);
32017         break;
32018       case NUMBER:
32019         jj_consume_token(NUMBER);
32020         break;
32021       case BFILE_BASE:
32022         jj_consume_token(BFILE_BASE);
32023         break;
32024       case BLOB_BASE:
32025         jj_consume_token(BLOB_BASE);
32026         break;
32027       case CLOB_BASE:
32028         jj_consume_token(CLOB_BASE);
32029         break;
32030       case DATE_BASE:
32031         jj_consume_token(DATE_BASE);
32032         break;
32033       case NUMBER_BASE:
32034         jj_consume_token(NUMBER_BASE);
32035         break;
32036       case OCIROWID:
32037         jj_consume_token(OCIROWID);
32038         break;
32039       case OPERATOR:
32040         jj_consume_token(OPERATOR);
32041         break;
32042       case OUT:
32043         jj_consume_token(OUT);
32044         break;
32045       case PLS_INTEGER:
32046         jj_consume_token(PLS_INTEGER);
32047         break;
32048       case POSITIVE:
32049         jj_consume_token(POSITIVE);
32050         break;
32051       case POSITIVEN:
32052         jj_consume_token(POSITIVEN);
32053         break;
32054       case PRAGMA:
32055         jj_consume_token(PRAGMA);
32056         break;
32057       case PRIOR:
32058         jj_consume_token(PRIOR);
32059         break;
32060       case PRIVATE:
32061         jj_consume_token(PRIVATE);
32062         break;
32063       case PROMPT:
32064         jj_consume_token(PROMPT);
32065         break;
32066       case RAISE:
32067         jj_consume_token(RAISE);
32068         break;
32069       case RAW:
32070         jj_consume_token(RAW);
32071         break;
32072       case ROWTYPE:
32073         jj_consume_token(ROWTYPE);
32074         break;
32075       case SEPARATE:
32076         jj_consume_token(SEPARATE);
32077         break;
32078       case SMALLINT:
32079         jj_consume_token(SMALLINT);
32080         break;
32081       case SQLCODE:
32082         jj_consume_token(SQLCODE);
32083         break;
32084       case SQLERRM:
32085         jj_consume_token(SQLERRM);
32086         break;
32087       case STDDEV:
32088         jj_consume_token(STDDEV);
32089         break;
32090       case SUM:
32091         jj_consume_token(SUM);
32092         break;
32093       case SYNONYM:
32094         jj_consume_token(SYNONYM);
32095         break;
32096       case SYSDATE:
32097         jj_consume_token(SYSDATE);
32098         break;
32099       case TRIGGER:
32100         jj_consume_token(TRIGGER);
32101         break;
32102       case TYPE:
32103         jj_consume_token(TYPE);
32104         break;
32105       case UI:
32106         jj_consume_token(UI);
32107         break;
32108       case VARCHAR:
32109         jj_consume_token(VARCHAR);
32110         break;
32111       case VARCHAR2:
32112         jj_consume_token(VARCHAR2);
32113         break;
32114       case INT:
32115         jj_consume_token(INT);
32116         break;
32117       case SIGNTYPE:
32118         jj_consume_token(SIGNTYPE);
32119         break;
32120       case STRING:
32121         jj_consume_token(STRING);
32122         break;
32123       case WHILE:
32124         jj_consume_token(WHILE);
32125         break;
32126       default:
32127         jj_la1[455] = jj_gen;
32128         jj_consume_token(-1);
32129         throw new ParseException();
32130       }
32131           jjtree.closeNodeScope(jjtn000, true);
32132           jjtc000 = false;
32133           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32134     } catch (Throwable jjte000) {
32135           if (jjtc000) {
32136             jjtree.clearNodeScope(jjtn000);
32137             jjtc000 = false;
32138           } else {
32139             jjtree.popNode();
32140           }
32141           if (jjte000 instanceof RuntimeException) {
32142             {if (true) throw (RuntimeException)jjte000;}
32143           }
32144           if (jjte000 instanceof ParseException) {
32145             {if (true) throw (ParseException)jjte000;}
32146           }
32147           {if (true) throw (Error)jjte000;}
32148     } finally {
32149           if (jjtc000) {
32150             jjtree.closeNodeScope(jjtn000, true);
32151           }
32152     }
32153     throw new Error("Missing return statement in function");
32154   }
32155 
32156   final public ASTTypeKeyword TypeKeyword() throws ParseException {
32157                                /*@bgen(jjtree) TypeKeyword */
32158   ASTTypeKeyword jjtn000 = new ASTTypeKeyword(this, JJTTYPEKEYWORD);
32159   boolean jjtc000 = true;
32160   jjtree.openNodeScope(jjtn000);
32161     try {
32162       switch (jj_nt.kind) {
32163       case BFILE_BASE:
32164         jj_consume_token(BFILE_BASE);
32165         break;
32166       case BLOB_BASE:
32167         jj_consume_token(BLOB_BASE);
32168         break;
32169       case CLOB_BASE:
32170         jj_consume_token(CLOB_BASE);
32171         break;
32172       case DATE_BASE:
32173         jj_consume_token(DATE_BASE);
32174         break;
32175       case NUMBER_BASE:
32176         jj_consume_token(NUMBER_BASE);
32177         break;
32178       case BOOLEAN:
32179         jj_consume_token(BOOLEAN);
32180         break;
32181       case DATE:
32182         jj_consume_token(DATE);
32183         break;
32184       case NUMBER:
32185         jj_consume_token(NUMBER);
32186         break;
32187       case FLOAT:
32188         jj_consume_token(FLOAT);
32189         break;
32190       case REAL:
32191         jj_consume_token(REAL);
32192         break;
32193       case INTEGER:
32194         jj_consume_token(INTEGER);
32195         break;
32196       case INT:
32197         jj_consume_token(INT);
32198         break;
32199       case SMALLINT:
32200         jj_consume_token(SMALLINT);
32201         break;
32202       case DECIMAL:
32203         jj_consume_token(DECIMAL);
32204         break;
32205       case NUMERIC:
32206         jj_consume_token(NUMERIC);
32207         break;
32208       case DEC:
32209         jj_consume_token(DEC);
32210         break;
32211       case BINARY_INTEGER:
32212         jj_consume_token(BINARY_INTEGER);
32213         break;
32214       case NATURAL:
32215         jj_consume_token(NATURAL);
32216         break;
32217       case NATURALN:
32218         jj_consume_token(NATURALN);
32219         break;
32220       case POSITIVE:
32221         jj_consume_token(POSITIVE);
32222         break;
32223       case POSITIVEN:
32224         jj_consume_token(POSITIVEN);
32225         break;
32226       case SIGNTYPE:
32227         jj_consume_token(SIGNTYPE);
32228         break;
32229       case VARCHAR2:
32230         jj_consume_token(VARCHAR2);
32231         break;
32232       case VARCHAR:
32233         jj_consume_token(VARCHAR);
32234         break;
32235       case STRING:
32236         jj_consume_token(STRING);
32237         break;
32238       case LONG:
32239         jj_consume_token(LONG);
32240         break;
32241       case RAW:
32242         jj_consume_token(RAW);
32243         break;
32244       case ROWID:
32245         jj_consume_token(ROWID);
32246         break;
32247       case CHAR:
32248         jj_consume_token(CHAR);
32249         break;
32250       case CHARACTER:
32251         jj_consume_token(CHARACTER);
32252         break;
32253       case MLSLABEL:
32254         jj_consume_token(MLSLABEL);
32255         break;
32256       case BLOB:
32257         jj_consume_token(BLOB);
32258         break;
32259       case CLOB:
32260         jj_consume_token(CLOB);
32261         break;
32262       case BFILE:
32263         jj_consume_token(BFILE);
32264         break;
32265       case NCHAR:
32266         jj_consume_token(NCHAR);
32267         break;
32268       case NVARCHAR2:
32269         jj_consume_token(NVARCHAR2);
32270         break;
32271       case NCLOB:
32272         jj_consume_token(NCLOB);
32273         break;
32274       case PLS_INTEGER:
32275         jj_consume_token(PLS_INTEGER);
32276         break;
32277       case TIME:
32278         jj_consume_token(TIME);
32279         break;
32280       case TIMESTAMP:
32281         jj_consume_token(TIMESTAMP);
32282         break;
32283       case UROWID:
32284         jj_consume_token(UROWID);
32285         break;
32286       case ARRAY:
32287         jj_consume_token(ARRAY);
32288         break;
32289       case AUTHID:
32290         jj_consume_token(AUTHID);
32291         break;
32292       case ACCESSIBLE:
32293         jj_consume_token(ACCESSIBLE);
32294         jj_consume_token(CHAR_BASE);
32295         break;
32296       case CURRVAL:
32297         jj_consume_token(CURRVAL);
32298         break;
32299       case HOUR:
32300         jj_consume_token(HOUR);
32301         break;
32302       case INTERVAL:
32303         jj_consume_token(INTERVAL);
32304         break;
32305       case MONTH:
32306         jj_consume_token(MONTH);
32307         break;
32308       case OCIROWID:
32309         jj_consume_token(OCIROWID);
32310         break;
32311       case RECORD:
32312         jj_consume_token(RECORD);
32313         break;
32314       case REF:
32315         jj_consume_token(REF);
32316         break;
32317       case ROW:
32318         jj_consume_token(ROW);
32319         break;
32320       case ROWNUM:
32321         jj_consume_token(ROWNUM);
32322         break;
32323       case ROWTYPE:
32324         jj_consume_token(ROWTYPE);
32325         break;
32326       case SECOND:
32327         jj_consume_token(SECOND);
32328         break;
32329       case SET:
32330         jj_consume_token(SET);
32331         break;
32332       case TABLE:
32333         jj_consume_token(TABLE);
32334         break;
32335       case TIMEZONE_REGION:
32336         jj_consume_token(TIMEZONE_REGION);
32337         break;
32338       case TIMEZONE_ABBR:
32339         jj_consume_token(TIMEZONE_ABBR);
32340         break;
32341       case TIMEZONE_MINUTE:
32342         jj_consume_token(TIMEZONE_MINUTE);
32343         break;
32344       case TIMEZONE_HOUR:
32345         jj_consume_token(TIMEZONE_HOUR);
32346         break;
32347       case DOUBLE:
32348         jj_consume_token(DOUBLE);
32349         break;
32350       case PRECISION:
32351         jj_consume_token(PRECISION);
32352         break;
32353       case VARRAY:
32354         jj_consume_token(VARRAY);
32355         break;
32356       case YEAR:
32357         jj_consume_token(YEAR);
32358         break;
32359       case LOCAL:
32360         jj_consume_token(LOCAL);
32361         break;
32362       case WITH:
32363         jj_consume_token(WITH);
32364         break;
32365       case ZONE:
32366         jj_consume_token(ZONE);
32367         break;
32368       case JAVA_INTERFACE_CLASS:
32369         jj_consume_token(JAVA_INTERFACE_CLASS);
32370         break;
32371       case SQLDATA_CLASS:
32372         jj_consume_token(SQLDATA_CLASS);
32373         break;
32374       case CUSTOMDATUM_CLASS:
32375         jj_consume_token(CUSTOMDATUM_CLASS);
32376         break;
32377       case ORADATA_CLASS:
32378         jj_consume_token(ORADATA_CLASS);
32379         break;
32380       default:
32381         jj_la1[456] = jj_gen;
32382         jj_consume_token(-1);
32383         throw new ParseException();
32384       }
32385           jjtree.closeNodeScope(jjtn000, true);
32386           jjtc000 = false;
32387           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32388     } finally {
32389           if (jjtc000) {
32390             jjtree.closeNodeScope(jjtn000, true);
32391           }
32392     }
32393     throw new Error("Missing return statement in function");
32394   }
32395 
32396   final public ASTJavaInterfaceClass JavaInterfaceClass() throws ParseException {
32397                                              /*@bgen(jjtree) JavaInterfaceClass */
32398   ASTJavaInterfaceClass jjtn000 = new ASTJavaInterfaceClass(this, JJTJAVAINTERFACECLASS);
32399   boolean jjtc000 = true;
32400   jjtree.openNodeScope(jjtn000);
32401     try {
32402       switch (jj_nt.kind) {
32403       case SQLDATA_CLASS:
32404         jj_consume_token(SQLDATA_CLASS);
32405         break;
32406       case CUSTOMDATUM_CLASS:
32407         jj_consume_token(CUSTOMDATUM_CLASS);
32408         break;
32409       case ORADATA_CLASS:
32410         jj_consume_token(ORADATA_CLASS);
32411         break;
32412       default:
32413         jj_la1[457] = jj_gen;
32414         jj_consume_token(-1);
32415         throw new ParseException();
32416       }
32417           jjtree.closeNodeScope(jjtn000, true);
32418           jjtc000 = false;
32419           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32420     } finally {
32421           if (jjtc000) {
32422             jjtree.closeNodeScope(jjtn000, true);
32423           }
32424     }
32425     throw new Error("Missing return statement in function");
32426   }
32427 
32428 /**
32429  * Tests, if the new Token if type ID is identical to the old Token of type ID.
32430  * 
32431  * 2006-05-18 - Matthias Hendler - added: Just for understanding javacc and not used,
32432  *                                        cause to many closing ENDs (IDENTIFIER) were mistyped.
32433  */
32434   final public PLSQLNode EqualsOldIDNewID(PLSQLNode pOldID) throws ParseException {
32435  /*@bgen(jjtree) EqualsOldIDNewID */
32436         ASTEqualsOldIDNewID jjtn000 = new ASTEqualsOldIDNewID(this, JJTEQUALSOLDIDNEWID);
32437         boolean jjtc000 = true;
32438         jjtree.openNodeScope(jjtn000);PLSQLNode newID;
32439         Token oldIDToken;
32440         Token newIDToken;
32441     try {
32442       newID = ID();
32443           jjtree.closeNodeScope(jjtn000, true);
32444           jjtc000 = false;
32445                 oldIDToken = (Token) ((AbstractPLSQLNode)pOldID).value ;
32446                 newIDToken = (Token) ((AbstractPLSQLNode)newID).value ;
32447                 if (oldIDToken.image.equals(newIDToken.image)) {
32448                         {if (true) return newID;}
32449                 } else {
32450                         {if (true) throw new ParseException("PLSQL syntax error on line "+newIDToken.beginLine+" at column "+newIDToken.beginColumn+"!\u005cn"
32451                                 + "Found \u005c""+newIDToken.image+"\u005c" but expected \u005c""+oldIDToken.image+"\u005c".");}
32452                 }
32453     } catch (Throwable jjte000) {
32454           if (jjtc000) {
32455             jjtree.clearNodeScope(jjtn000);
32456             jjtc000 = false;
32457           } else {
32458             jjtree.popNode();
32459           }
32460           if (jjte000 instanceof RuntimeException) {
32461             {if (true) throw (RuntimeException)jjte000;}
32462           }
32463           if (jjte000 instanceof ParseException) {
32464             {if (true) throw (ParseException)jjte000;}
32465           }
32466           {if (true) throw (Error)jjte000;}
32467     } finally {
32468           if (jjtc000) {
32469             jjtree.closeNodeScope(jjtn000, true);
32470           }
32471     }
32472     throw new Error("Missing return statement in function");
32473   }
32474 
32475   private boolean jj_2_1(int xla) {
32476     jj_la = xla; jj_lastpos = jj_scanpos = token;
32477     try { return !jj_3_1(); }
32478     catch(LookaheadSuccess ls) { return true; }
32479     finally { jj_save(0, xla); }
32480   }
32481 
32482   private boolean jj_2_2(int xla) {
32483     jj_la = xla; jj_lastpos = jj_scanpos = token;
32484     try { return !jj_3_2(); }
32485     catch(LookaheadSuccess ls) { return true; }
32486     finally { jj_save(1, xla); }
32487   }
32488 
32489   private boolean jj_2_3(int xla) {
32490     jj_la = xla; jj_lastpos = jj_scanpos = token;
32491     try { return !jj_3_3(); }
32492     catch(LookaheadSuccess ls) { return true; }
32493     finally { jj_save(2, xla); }
32494   }
32495 
32496   private boolean jj_2_4(int xla) {
32497     jj_la = xla; jj_lastpos = jj_scanpos = token;
32498     try { return !jj_3_4(); }
32499     catch(LookaheadSuccess ls) { return true; }
32500     finally { jj_save(3, xla); }
32501   }
32502 
32503   private boolean jj_2_5(int xla) {
32504     jj_la = xla; jj_lastpos = jj_scanpos = token;
32505     try { return !jj_3_5(); }
32506     catch(LookaheadSuccess ls) { return true; }
32507     finally { jj_save(4, xla); }
32508   }
32509 
32510   private boolean jj_2_6(int xla) {
32511     jj_la = xla; jj_lastpos = jj_scanpos = token;
32512     try { return !jj_3_6(); }
32513     catch(LookaheadSuccess ls) { return true; }
32514     finally { jj_save(5, xla); }
32515   }
32516 
32517   private boolean jj_2_7(int xla) {
32518     jj_la = xla; jj_lastpos = jj_scanpos = token;
32519     try { return !jj_3_7(); }
32520     catch(LookaheadSuccess ls) { return true; }
32521     finally { jj_save(6, xla); }
32522   }
32523 
32524   private boolean jj_2_8(int xla) {
32525     jj_la = xla; jj_lastpos = jj_scanpos = token;
32526     try { return !jj_3_8(); }
32527     catch(LookaheadSuccess ls) { return true; }
32528     finally { jj_save(7, xla); }
32529   }
32530 
32531   private boolean jj_2_9(int xla) {
32532     jj_la = xla; jj_lastpos = jj_scanpos = token;
32533     try { return !jj_3_9(); }
32534     catch(LookaheadSuccess ls) { return true; }
32535     finally { jj_save(8, xla); }
32536   }
32537 
32538   private boolean jj_2_10(int xla) {
32539     jj_la = xla; jj_lastpos = jj_scanpos = token;
32540     try { return !jj_3_10(); }
32541     catch(LookaheadSuccess ls) { return true; }
32542     finally { jj_save(9, xla); }
32543   }
32544 
32545   private boolean jj_2_11(int xla) {
32546     jj_la = xla; jj_lastpos = jj_scanpos = token;
32547     try { return !jj_3_11(); }
32548     catch(LookaheadSuccess ls) { return true; }
32549     finally { jj_save(10, xla); }
32550   }
32551 
32552   private boolean jj_2_12(int xla) {
32553     jj_la = xla; jj_lastpos = jj_scanpos = token;
32554     try { return !jj_3_12(); }
32555     catch(LookaheadSuccess ls) { return true; }
32556     finally { jj_save(11, xla); }
32557   }
32558 
32559   private boolean jj_2_13(int xla) {
32560     jj_la = xla; jj_lastpos = jj_scanpos = token;
32561     try { return !jj_3_13(); }
32562     catch(LookaheadSuccess ls) { return true; }
32563     finally { jj_save(12, xla); }
32564   }
32565 
32566   private boolean jj_2_14(int xla) {
32567     jj_la = xla; jj_lastpos = jj_scanpos = token;
32568     try { return !jj_3_14(); }
32569     catch(LookaheadSuccess ls) { return true; }
32570     finally { jj_save(13, xla); }
32571   }
32572 
32573   private boolean jj_2_15(int xla) {
32574     jj_la = xla; jj_lastpos = jj_scanpos = token;
32575     try { return !jj_3_15(); }
32576     catch(LookaheadSuccess ls) { return true; }
32577     finally { jj_save(14, xla); }
32578   }
32579 
32580   private boolean jj_2_16(int xla) {
32581     jj_la = xla; jj_lastpos = jj_scanpos = token;
32582     try { return !jj_3_16(); }
32583     catch(LookaheadSuccess ls) { return true; }
32584     finally { jj_save(15, xla); }
32585   }
32586 
32587   private boolean jj_2_17(int xla) {
32588     jj_la = xla; jj_lastpos = jj_scanpos = token;
32589     try { return !jj_3_17(); }
32590     catch(LookaheadSuccess ls) { return true; }
32591     finally { jj_save(16, xla); }
32592   }
32593 
32594   private boolean jj_2_18(int xla) {
32595     jj_la = xla; jj_lastpos = jj_scanpos = token;
32596     try { return !jj_3_18(); }
32597     catch(LookaheadSuccess ls) { return true; }
32598     finally { jj_save(17, xla); }
32599   }
32600 
32601   private boolean jj_2_19(int xla) {
32602     jj_la = xla; jj_lastpos = jj_scanpos = token;
32603     try { return !jj_3_19(); }
32604     catch(LookaheadSuccess ls) { return true; }
32605     finally { jj_save(18, xla); }
32606   }
32607 
32608   private boolean jj_2_20(int xla) {
32609     jj_la = xla; jj_lastpos = jj_scanpos = token;
32610     try { return !jj_3_20(); }
32611     catch(LookaheadSuccess ls) { return true; }
32612     finally { jj_save(19, xla); }
32613   }
32614 
32615   private boolean jj_2_21(int xla) {
32616     jj_la = xla; jj_lastpos = jj_scanpos = token;
32617     try { return !jj_3_21(); }
32618     catch(LookaheadSuccess ls) { return true; }
32619     finally { jj_save(20, xla); }
32620   }
32621 
32622   private boolean jj_2_22(int xla) {
32623     jj_la = xla; jj_lastpos = jj_scanpos = token;
32624     try { return !jj_3_22(); }
32625     catch(LookaheadSuccess ls) { return true; }
32626     finally { jj_save(21, xla); }
32627   }
32628 
32629   private boolean jj_2_23(int xla) {
32630     jj_la = xla; jj_lastpos = jj_scanpos = token;
32631     try { return !jj_3_23(); }
32632     catch(LookaheadSuccess ls) { return true; }
32633     finally { jj_save(22, xla); }
32634   }
32635 
32636   private boolean jj_2_24(int xla) {
32637     jj_la = xla; jj_lastpos = jj_scanpos = token;
32638     try { return !jj_3_24(); }
32639     catch(LookaheadSuccess ls) { return true; }
32640     finally { jj_save(23, xla); }
32641   }
32642 
32643   private boolean jj_2_25(int xla) {
32644     jj_la = xla; jj_lastpos = jj_scanpos = token;
32645     try { return !jj_3_25(); }
32646     catch(LookaheadSuccess ls) { return true; }
32647     finally { jj_save(24, xla); }
32648   }
32649 
32650   private boolean jj_2_26(int xla) {
32651     jj_la = xla; jj_lastpos = jj_scanpos = token;
32652     try { return !jj_3_26(); }
32653     catch(LookaheadSuccess ls) { return true; }
32654     finally { jj_save(25, xla); }
32655   }
32656 
32657   private boolean jj_2_27(int xla) {
32658     jj_la = xla; jj_lastpos = jj_scanpos = token;
32659     try { return !jj_3_27(); }
32660     catch(LookaheadSuccess ls) { return true; }
32661     finally { jj_save(26, xla); }
32662   }
32663 
32664   private boolean jj_2_28(int xla) {
32665     jj_la = xla; jj_lastpos = jj_scanpos = token;
32666     try { return !jj_3_28(); }
32667     catch(LookaheadSuccess ls) { return true; }
32668     finally { jj_save(27, xla); }
32669   }
32670 
32671   private boolean jj_2_29(int xla) {
32672     jj_la = xla; jj_lastpos = jj_scanpos = token;
32673     try { return !jj_3_29(); }
32674     catch(LookaheadSuccess ls) { return true; }
32675     finally { jj_save(28, xla); }
32676   }
32677 
32678   private boolean jj_2_30(int xla) {
32679     jj_la = xla; jj_lastpos = jj_scanpos = token;
32680     try { return !jj_3_30(); }
32681     catch(LookaheadSuccess ls) { return true; }
32682     finally { jj_save(29, xla); }
32683   }
32684 
32685   private boolean jj_2_31(int xla) {
32686     jj_la = xla; jj_lastpos = jj_scanpos = token;
32687     try { return !jj_3_31(); }
32688     catch(LookaheadSuccess ls) { return true; }
32689     finally { jj_save(30, xla); }
32690   }
32691 
32692   private boolean jj_2_32(int xla) {
32693     jj_la = xla; jj_lastpos = jj_scanpos = token;
32694     try { return !jj_3_32(); }
32695     catch(LookaheadSuccess ls) { return true; }
32696     finally { jj_save(31, xla); }
32697   }
32698 
32699   private boolean jj_2_33(int xla) {
32700     jj_la = xla; jj_lastpos = jj_scanpos = token;
32701     try { return !jj_3_33(); }
32702     catch(LookaheadSuccess ls) { return true; }
32703     finally { jj_save(32, xla); }
32704   }
32705 
32706   private boolean jj_2_34(int xla) {
32707     jj_la = xla; jj_lastpos = jj_scanpos = token;
32708     try { return !jj_3_34(); }
32709     catch(LookaheadSuccess ls) { return true; }
32710     finally { jj_save(33, xla); }
32711   }
32712 
32713   private boolean jj_2_35(int xla) {
32714     jj_la = xla; jj_lastpos = jj_scanpos = token;
32715     try { return !jj_3_35(); }
32716     catch(LookaheadSuccess ls) { return true; }
32717     finally { jj_save(34, xla); }
32718   }
32719 
32720   private boolean jj_2_36(int xla) {
32721     jj_la = xla; jj_lastpos = jj_scanpos = token;
32722     try { return !jj_3_36(); }
32723     catch(LookaheadSuccess ls) { return true; }
32724     finally { jj_save(35, xla); }
32725   }
32726 
32727   private boolean jj_2_37(int xla) {
32728     jj_la = xla; jj_lastpos = jj_scanpos = token;
32729     try { return !jj_3_37(); }
32730     catch(LookaheadSuccess ls) { return true; }
32731     finally { jj_save(36, xla); }
32732   }
32733 
32734   private boolean jj_2_38(int xla) {
32735     jj_la = xla; jj_lastpos = jj_scanpos = token;
32736     try { return !jj_3_38(); }
32737     catch(LookaheadSuccess ls) { return true; }
32738     finally { jj_save(37, xla); }
32739   }
32740 
32741   private boolean jj_2_39(int xla) {
32742     jj_la = xla; jj_lastpos = jj_scanpos = token;
32743     try { return !jj_3_39(); }
32744     catch(LookaheadSuccess ls) { return true; }
32745     finally { jj_save(38, xla); }
32746   }
32747 
32748   private boolean jj_2_40(int xla) {
32749     jj_la = xla; jj_lastpos = jj_scanpos = token;
32750     try { return !jj_3_40(); }
32751     catch(LookaheadSuccess ls) { return true; }
32752     finally { jj_save(39, xla); }
32753   }
32754 
32755   private boolean jj_2_41(int xla) {
32756     jj_la = xla; jj_lastpos = jj_scanpos = token;
32757     try { return !jj_3_41(); }
32758     catch(LookaheadSuccess ls) { return true; }
32759     finally { jj_save(40, xla); }
32760   }
32761 
32762   private boolean jj_2_42(int xla) {
32763     jj_la = xla; jj_lastpos = jj_scanpos = token;
32764     try { return !jj_3_42(); }
32765     catch(LookaheadSuccess ls) { return true; }
32766     finally { jj_save(41, xla); }
32767   }
32768 
32769   private boolean jj_2_43(int xla) {
32770     jj_la = xla; jj_lastpos = jj_scanpos = token;
32771     try { return !jj_3_43(); }
32772     catch(LookaheadSuccess ls) { return true; }
32773     finally { jj_save(42, xla); }
32774   }
32775 
32776   private boolean jj_2_44(int xla) {
32777     jj_la = xla; jj_lastpos = jj_scanpos = token;
32778     try { return !jj_3_44(); }
32779     catch(LookaheadSuccess ls) { return true; }
32780     finally { jj_save(43, xla); }
32781   }
32782 
32783   private boolean jj_2_45(int xla) {
32784     jj_la = xla; jj_lastpos = jj_scanpos = token;
32785     try { return !jj_3_45(); }
32786     catch(LookaheadSuccess ls) { return true; }
32787     finally { jj_save(44, xla); }
32788   }
32789 
32790   private boolean jj_2_46(int xla) {
32791     jj_la = xla; jj_lastpos = jj_scanpos = token;
32792     try { return !jj_3_46(); }
32793     catch(LookaheadSuccess ls) { return true; }
32794     finally { jj_save(45, xla); }
32795   }
32796 
32797   private boolean jj_2_47(int xla) {
32798     jj_la = xla; jj_lastpos = jj_scanpos = token;
32799     try { return !jj_3_47(); }
32800     catch(LookaheadSuccess ls) { return true; }
32801     finally { jj_save(46, xla); }
32802   }
32803 
32804   private boolean jj_2_48(int xla) {
32805     jj_la = xla; jj_lastpos = jj_scanpos = token;
32806     try { return !jj_3_48(); }
32807     catch(LookaheadSuccess ls) { return true; }
32808     finally { jj_save(47, xla); }
32809   }
32810 
32811   private boolean jj_2_49(int xla) {
32812     jj_la = xla; jj_lastpos = jj_scanpos = token;
32813     try { return !jj_3_49(); }
32814     catch(LookaheadSuccess ls) { return true; }
32815     finally { jj_save(48, xla); }
32816   }
32817 
32818   private boolean jj_2_50(int xla) {
32819     jj_la = xla; jj_lastpos = jj_scanpos = token;
32820     try { return !jj_3_50(); }
32821     catch(LookaheadSuccess ls) { return true; }
32822     finally { jj_save(49, xla); }
32823   }
32824 
32825   private boolean jj_2_51(int xla) {
32826     jj_la = xla; jj_lastpos = jj_scanpos = token;
32827     try { return !jj_3_51(); }
32828     catch(LookaheadSuccess ls) { return true; }
32829     finally { jj_save(50, xla); }
32830   }
32831 
32832   private boolean jj_2_52(int xla) {
32833     jj_la = xla; jj_lastpos = jj_scanpos = token;
32834     try { return !jj_3_52(); }
32835     catch(LookaheadSuccess ls) { return true; }
32836     finally { jj_save(51, xla); }
32837   }
32838 
32839   private boolean jj_2_53(int xla) {
32840     jj_la = xla; jj_lastpos = jj_scanpos = token;
32841     try { return !jj_3_53(); }
32842     catch(LookaheadSuccess ls) { return true; }
32843     finally { jj_save(52, xla); }
32844   }
32845 
32846   private boolean jj_2_54(int xla) {
32847     jj_la = xla; jj_lastpos = jj_scanpos = token;
32848     try { return !jj_3_54(); }
32849     catch(LookaheadSuccess ls) { return true; }
32850     finally { jj_save(53, xla); }
32851   }
32852 
32853   private boolean jj_2_55(int xla) {
32854     jj_la = xla; jj_lastpos = jj_scanpos = token;
32855     try { return !jj_3_55(); }
32856     catch(LookaheadSuccess ls) { return true; }
32857     finally { jj_save(54, xla); }
32858   }
32859 
32860   private boolean jj_2_56(int xla) {
32861     jj_la = xla; jj_lastpos = jj_scanpos = token;
32862     try { return !jj_3_56(); }
32863     catch(LookaheadSuccess ls) { return true; }
32864     finally { jj_save(55, xla); }
32865   }
32866 
32867   private boolean jj_2_57(int xla) {
32868     jj_la = xla; jj_lastpos = jj_scanpos = token;
32869     try { return !jj_3_57(); }
32870     catch(LookaheadSuccess ls) { return true; }
32871     finally { jj_save(56, xla); }
32872   }
32873 
32874   private boolean jj_2_58(int xla) {
32875     jj_la = xla; jj_lastpos = jj_scanpos = token;
32876     try { return !jj_3_58(); }
32877     catch(LookaheadSuccess ls) { return true; }
32878     finally { jj_save(57, xla); }
32879   }
32880 
32881   private boolean jj_2_59(int xla) {
32882     jj_la = xla; jj_lastpos = jj_scanpos = token;
32883     try { return !jj_3_59(); }
32884     catch(LookaheadSuccess ls) { return true; }
32885     finally { jj_save(58, xla); }
32886   }
32887 
32888   private boolean jj_2_60(int xla) {
32889     jj_la = xla; jj_lastpos = jj_scanpos = token;
32890     try { return !jj_3_60(); }
32891     catch(LookaheadSuccess ls) { return true; }
32892     finally { jj_save(59, xla); }
32893   }
32894 
32895   private boolean jj_2_61(int xla) {
32896     jj_la = xla; jj_lastpos = jj_scanpos = token;
32897     try { return !jj_3_61(); }
32898     catch(LookaheadSuccess ls) { return true; }
32899     finally { jj_save(60, xla); }
32900   }
32901 
32902   private boolean jj_2_62(int xla) {
32903     jj_la = xla; jj_lastpos = jj_scanpos = token;
32904     try { return !jj_3_62(); }
32905     catch(LookaheadSuccess ls) { return true; }
32906     finally { jj_save(61, xla); }
32907   }
32908 
32909   private boolean jj_2_63(int xla) {
32910     jj_la = xla; jj_lastpos = jj_scanpos = token;
32911     try { return !jj_3_63(); }
32912     catch(LookaheadSuccess ls) { return true; }
32913     finally { jj_save(62, xla); }
32914   }
32915 
32916   private boolean jj_2_64(int xla) {
32917     jj_la = xla; jj_lastpos = jj_scanpos = token;
32918     try { return !jj_3_64(); }
32919     catch(LookaheadSuccess ls) { return true; }
32920     finally { jj_save(63, xla); }
32921   }
32922 
32923   private boolean jj_2_65(int xla) {
32924     jj_la = xla; jj_lastpos = jj_scanpos = token;
32925     try { return !jj_3_65(); }
32926     catch(LookaheadSuccess ls) { return true; }
32927     finally { jj_save(64, xla); }
32928   }
32929 
32930   private boolean jj_2_66(int xla) {
32931     jj_la = xla; jj_lastpos = jj_scanpos = token;
32932     try { return !jj_3_66(); }
32933     catch(LookaheadSuccess ls) { return true; }
32934     finally { jj_save(65, xla); }
32935   }
32936 
32937   private boolean jj_2_67(int xla) {
32938     jj_la = xla; jj_lastpos = jj_scanpos = token;
32939     try { return !jj_3_67(); }
32940     catch(LookaheadSuccess ls) { return true; }
32941     finally { jj_save(66, xla); }
32942   }
32943 
32944   private boolean jj_2_68(int xla) {
32945     jj_la = xla; jj_lastpos = jj_scanpos = token;
32946     try { return !jj_3_68(); }
32947     catch(LookaheadSuccess ls) { return true; }
32948     finally { jj_save(67, xla); }
32949   }
32950 
32951   private boolean jj_2_69(int xla) {
32952     jj_la = xla; jj_lastpos = jj_scanpos = token;
32953     try { return !jj_3_69(); }
32954     catch(LookaheadSuccess ls) { return true; }
32955     finally { jj_save(68, xla); }
32956   }
32957 
32958   private boolean jj_2_70(int xla) {
32959     jj_la = xla; jj_lastpos = jj_scanpos = token;
32960     try { return !jj_3_70(); }
32961     catch(LookaheadSuccess ls) { return true; }
32962     finally { jj_save(69, xla); }
32963   }
32964 
32965   private boolean jj_2_71(int xla) {
32966     jj_la = xla; jj_lastpos = jj_scanpos = token;
32967     try { return !jj_3_71(); }
32968     catch(LookaheadSuccess ls) { return true; }
32969     finally { jj_save(70, xla); }
32970   }
32971 
32972   private boolean jj_2_72(int xla) {
32973     jj_la = xla; jj_lastpos = jj_scanpos = token;
32974     try { return !jj_3_72(); }
32975     catch(LookaheadSuccess ls) { return true; }
32976     finally { jj_save(71, xla); }
32977   }
32978 
32979   private boolean jj_2_73(int xla) {
32980     jj_la = xla; jj_lastpos = jj_scanpos = token;
32981     try { return !jj_3_73(); }
32982     catch(LookaheadSuccess ls) { return true; }
32983     finally { jj_save(72, xla); }
32984   }
32985 
32986   private boolean jj_2_74(int xla) {
32987     jj_la = xla; jj_lastpos = jj_scanpos = token;
32988     try { return !jj_3_74(); }
32989     catch(LookaheadSuccess ls) { return true; }
32990     finally { jj_save(73, xla); }
32991   }
32992 
32993   private boolean jj_2_75(int xla) {
32994     jj_la = xla; jj_lastpos = jj_scanpos = token;
32995     try { return !jj_3_75(); }
32996     catch(LookaheadSuccess ls) { return true; }
32997     finally { jj_save(74, xla); }
32998   }
32999 
33000   private boolean jj_2_76(int xla) {
33001     jj_la = xla; jj_lastpos = jj_scanpos = token;
33002     try { return !jj_3_76(); }
33003     catch(LookaheadSuccess ls) { return true; }
33004     finally { jj_save(75, xla); }
33005   }
33006 
33007   private boolean jj_2_77(int xla) {
33008     jj_la = xla; jj_lastpos = jj_scanpos = token;
33009     try { return !jj_3_77(); }
33010     catch(LookaheadSuccess ls) { return true; }
33011     finally { jj_save(76, xla); }
33012   }
33013 
33014   private boolean jj_2_78(int xla) {
33015     jj_la = xla; jj_lastpos = jj_scanpos = token;
33016     try { return !jj_3_78(); }
33017     catch(LookaheadSuccess ls) { return true; }
33018     finally { jj_save(77, xla); }
33019   }
33020 
33021   private boolean jj_2_79(int xla) {
33022     jj_la = xla; jj_lastpos = jj_scanpos = token;
33023     try { return !jj_3_79(); }
33024     catch(LookaheadSuccess ls) { return true; }
33025     finally { jj_save(78, xla); }
33026   }
33027 
33028   private boolean jj_2_80(int xla) {
33029     jj_la = xla; jj_lastpos = jj_scanpos = token;
33030     try { return !jj_3_80(); }
33031     catch(LookaheadSuccess ls) { return true; }
33032     finally { jj_save(79, xla); }
33033   }
33034 
33035   private boolean jj_2_81(int xla) {
33036     jj_la = xla; jj_lastpos = jj_scanpos = token;
33037     try { return !jj_3_81(); }
33038     catch(LookaheadSuccess ls) { return true; }
33039     finally { jj_save(80, xla); }
33040   }
33041 
33042   private boolean jj_2_82(int xla) {
33043     jj_la = xla; jj_lastpos = jj_scanpos = token;
33044     try { return !jj_3_82(); }
33045     catch(LookaheadSuccess ls) { return true; }
33046     finally { jj_save(81, xla); }
33047   }
33048 
33049   private boolean jj_2_83(int xla) {
33050     jj_la = xla; jj_lastpos = jj_scanpos = token;
33051     try { return !jj_3_83(); }
33052     catch(LookaheadSuccess ls) { return true; }
33053     finally { jj_save(82, xla); }
33054   }
33055 
33056   private boolean jj_2_84(int xla) {
33057     jj_la = xla; jj_lastpos = jj_scanpos = token;
33058     try { return !jj_3_84(); }
33059     catch(LookaheadSuccess ls) { return true; }
33060     finally { jj_save(83, xla); }
33061   }
33062 
33063   private boolean jj_3R_287() {
33064     if (jj_scan_token(NAME)) return true;
33065     Token xsp;
33066     xsp = jj_scanpos;
33067     if (jj_scan_token(420)) {
33068     jj_scanpos = xsp;
33069     if (jj_scan_token(428)) {
33070     jj_scanpos = xsp;
33071     if (jj_3R_562()) return true;
33072     }
33073     }
33074     return false;
33075   }
33076 
33077   private boolean jj_3R_527() {
33078     if (jj_scan_token(INDEX)) return true;
33079     if (jj_scan_token(BY)) return true;
33080     if (jj_3R_235()) return true;
33081     return false;
33082   }
33083 
33084   private boolean jj_3R_523() {
33085     if (jj_scan_token(6)) return true;
33086     if (jj_3R_521()) return true;
33087     return false;
33088   }
33089 
33090   private boolean jj_3R_200() {
33091     Token xsp;
33092     xsp = jj_scanpos;
33093     if (jj_3R_286()) {
33094     jj_scanpos = xsp;
33095     if (jj_3R_287()) {
33096     jj_scanpos = xsp;
33097     if (jj_3R_288()) {
33098     jj_scanpos = xsp;
33099     if (jj_3R_289()) return true;
33100     }
33101     }
33102     }
33103     return false;
33104   }
33105 
33106   private boolean jj_3R_286() {
33107     if (jj_scan_token(LIBRARY)) return true;
33108     Token xsp;
33109     xsp = jj_scanpos;
33110     if (jj_scan_token(420)) {
33111     jj_scanpos = xsp;
33112     if (jj_scan_token(428)) {
33113     jj_scanpos = xsp;
33114     if (jj_3R_561()) return true;
33115     }
33116     }
33117     xsp = jj_scanpos;
33118     if (jj_3R_629()) jj_scanpos = xsp;
33119     return false;
33120   }
33121 
33122   private boolean jj_3_73() {
33123     if (jj_scan_token(OF)) return true;
33124     if (jj_3R_124()) return true;
33125     Token xsp;
33126     while (true) {
33127       xsp = jj_scanpos;
33128       if (jj_3R_150()) { jj_scanpos = xsp; break; }
33129     }
33130     return false;
33131   }
33132 
33133   private boolean jj_3R_522() {
33134     if (jj_scan_token(6)) return true;
33135     if (jj_3R_521()) return true;
33136     return false;
33137   }
33138 
33139   private boolean jj_3R_199() {
33140     if (jj_scan_token(LANGUAGE)) return true;
33141     Token xsp;
33142     xsp = jj_scanpos;
33143     if (jj_scan_token(420)) {
33144     jj_scanpos = xsp;
33145     if (jj_scan_token(154)) return true;
33146     }
33147     return false;
33148   }
33149 
33150   private boolean jj_3R_564() {
33151     Token xsp;
33152     xsp = jj_scanpos;
33153     if (jj_scan_token(183)) jj_scanpos = xsp;
33154     if (jj_scan_token(NULL)) return true;
33155     return false;
33156   }
33157 
33158   private boolean jj_3R_529() {
33159     if (jj_scan_token(6)) return true;
33160     if (jj_3R_233()) return true;
33161     return false;
33162   }
33163 
33164   private boolean jj_3R_524() {
33165     if (jj_scan_token(VARYING)) return true;
33166     if (jj_scan_token(ARRAY)) return true;
33167     return false;
33168   }
33169 
33170   private boolean jj_3R_528() {
33171     if (jj_scan_token(RETURN)) return true;
33172     if (jj_3R_235()) return true;
33173     return false;
33174   }
33175 
33176   private boolean jj_3R_526() {
33177     if (jj_scan_token(NOT)) return true;
33178     if (jj_scan_token(NULL)) return true;
33179     return false;
33180   }
33181 
33182   private boolean jj_3R_266() {
33183     Token xsp;
33184     xsp = jj_scanpos;
33185     if (jj_scan_token(100)) {
33186     jj_scanpos = xsp;
33187     if (jj_scan_token(182)) return true;
33188     }
33189     return false;
33190   }
33191 
33192   private boolean jj_3R_123() {
33193     Token xsp;
33194     xsp = jj_scanpos;
33195     if (jj_scan_token(114)) {
33196     jj_scanpos = xsp;
33197     if (jj_3R_199()) return true;
33198     }
33199     while (true) {
33200       xsp = jj_scanpos;
33201       if (jj_3R_200()) { jj_scanpos = xsp; break; }
33202     }
33203     return false;
33204   }
33205 
33206   private boolean jj_3R_498() {
33207     if (jj_3R_235()) return true;
33208     return false;
33209   }
33210 
33211   private boolean jj_3R_497() {
33212     if (jj_scan_token(5)) return true;
33213     if (jj_3R_233()) return true;
33214     Token xsp;
33215     while (true) {
33216       xsp = jj_scanpos;
33217       if (jj_3R_529()) { jj_scanpos = xsp; break; }
33218     }
33219     if (jj_scan_token(7)) return true;
33220     return false;
33221   }
33222 
33223   private boolean jj_3R_268() {
33224     Token xsp;
33225     xsp = jj_scanpos;
33226     if (jj_scan_token(93)) {
33227     jj_scanpos = xsp;
33228     if (jj_scan_token(144)) {
33229     jj_scanpos = xsp;
33230     if (jj_scan_token(297)) return true;
33231     }
33232     }
33233     return false;
33234   }
33235 
33236   private boolean jj_3_76() {
33237     if (jj_3R_124()) return true;
33238     if (jj_scan_token(3)) return true;
33239     return false;
33240   }
33241 
33242   private boolean jj_3R_178() {
33243     Token xsp;
33244     xsp = jj_scanpos;
33245     if (jj_3_76()) jj_scanpos = xsp;
33246     if (jj_3R_124()) return true;
33247     return false;
33248   }
33249 
33250   private boolean jj_3_77() {
33251     if (jj_scan_token(NESTED)) return true;
33252     if (jj_scan_token(TABLE)) return true;
33253     return false;
33254   }
33255 
33256   private boolean jj_3R_496() {
33257     if (jj_scan_token(REF)) return true;
33258     if (jj_scan_token(CURSOR)) return true;
33259     Token xsp;
33260     xsp = jj_scanpos;
33261     if (jj_3R_528()) jj_scanpos = xsp;
33262     return false;
33263   }
33264 
33265   private boolean jj_3R_521() {
33266     if (jj_3R_124()) return true;
33267     if (jj_3R_235()) return true;
33268     Token xsp;
33269     xsp = jj_scanpos;
33270     if (jj_3R_564()) jj_scanpos = xsp;
33271     xsp = jj_scanpos;
33272     if (jj_3R_565()) jj_scanpos = xsp;
33273     return false;
33274   }
33275 
33276   private boolean jj_3R_495() {
33277     Token xsp;
33278     xsp = jj_scanpos;
33279     if (jj_scan_token(271)) {
33280     jj_scanpos = xsp;
33281     if (jj_scan_token(310)) {
33282     jj_scanpos = xsp;
33283     if (jj_3R_524()) return true;
33284     }
33285     }
33286     xsp = jj_scanpos;
33287     if (jj_3R_525()) jj_scanpos = xsp;
33288     if (jj_scan_token(OF)) return true;
33289     if (jj_3R_235()) return true;
33290     xsp = jj_scanpos;
33291     if (jj_3R_526()) jj_scanpos = xsp;
33292     xsp = jj_scanpos;
33293     if (jj_3R_527()) jj_scanpos = xsp;
33294     return false;
33295   }
33296 
33297   private boolean jj_3R_177() {
33298     if (jj_scan_token(OR)) return true;
33299     Token xsp;
33300     xsp = jj_scanpos;
33301     if (jj_3R_268()) {
33302     jj_scanpos = xsp;
33303     if (jj_3R_269()) return true;
33304     }
33305     return false;
33306   }
33307 
33308   private boolean jj_3R_494() {
33309     if (jj_scan_token(RECORD)) return true;
33310     if (jj_scan_token(5)) return true;
33311     if (jj_3R_521()) return true;
33312     Token xsp;
33313     while (true) {
33314       xsp = jj_scanpos;
33315       if (jj_3R_523()) { jj_scanpos = xsp; break; }
33316     }
33317     if (jj_scan_token(7)) return true;
33318     return false;
33319   }
33320 
33321   private boolean jj_3R_175() {
33322     Token xsp;
33323     xsp = jj_scanpos;
33324     if (jj_scan_token(93)) {
33325     jj_scanpos = xsp;
33326     if (jj_scan_token(144)) {
33327     jj_scanpos = xsp;
33328     if (jj_scan_token(297)) return true;
33329     }
33330     }
33331     xsp = jj_scanpos;
33332     if (jj_3_73()) jj_scanpos = xsp;
33333     return false;
33334   }
33335 
33336   private boolean jj_3R_265() {
33337     if (jj_scan_token(OR)) return true;
33338     if (jj_scan_token(REPLACE)) return true;
33339     return false;
33340   }
33341 
33342   private boolean jj_3R_493() {
33343     if (jj_scan_token(OBJECT)) return true;
33344     if (jj_scan_token(5)) return true;
33345     if (jj_3R_521()) return true;
33346     Token xsp;
33347     while (true) {
33348       xsp = jj_scanpos;
33349       if (jj_3R_522()) { jj_scanpos = xsp; break; }
33350     }
33351     if (jj_scan_token(7)) return true;
33352     return false;
33353   }
33354 
33355   private boolean jj_3R_174() {
33356     if (jj_scan_token(CREATE)) return true;
33357     Token xsp;
33358     xsp = jj_scanpos;
33359     if (jj_3R_265()) jj_scanpos = xsp;
33360     xsp = jj_scanpos;
33361     if (jj_3R_266()) jj_scanpos = xsp;
33362     return false;
33363   }
33364 
33365   private boolean jj_3R_108() {
33366     Token xsp;
33367     xsp = jj_scanpos;
33368     if (jj_3R_174()) jj_scanpos = xsp;
33369     if (jj_scan_token(TRIGGER)) return true;
33370     if (jj_3R_154()) return true;
33371     xsp = jj_scanpos;
33372     if (jj_scan_token(322)) {
33373     jj_scanpos = xsp;
33374     if (jj_scan_token(321)) {
33375     jj_scanpos = xsp;
33376     if (jj_scan_token(323)) {
33377     jj_scanpos = xsp;
33378     if (jj_scan_token(121)) return true;
33379     }
33380     }
33381     }
33382     xsp = jj_scanpos;
33383     if (jj_3R_175()) {
33384     jj_scanpos = xsp;
33385     if (jj_3R_176()) return true;
33386     }
33387     while (true) {
33388       xsp = jj_scanpos;
33389       if (jj_3R_177()) { jj_scanpos = xsp; break; }
33390     }
33391     if (jj_scan_token(ON)) return true;
33392     xsp = jj_scanpos;
33393     if (jj_scan_token(348)) {
33394     jj_scanpos = xsp;
33395     if (jj_3_77()) {
33396     jj_scanpos = xsp;
33397     if (jj_3R_178()) return true;
33398     }
33399     }
33400     return false;
33401   }
33402 
33403   private boolean jj_3R_640() {
33404     if (jj_3R_173()) return true;
33405     return false;
33406   }
33407 
33408   private boolean jj_3_44() {
33409     if (jj_scan_token(NEW)) return true;
33410     Token xsp;
33411     xsp = jj_scanpos;
33412     if (jj_scan_token(68)) {
33413     jj_scanpos = xsp;
33414     if (jj_scan_token(191)) {
33415     jj_scanpos = xsp;
33416     if (jj_scan_token(190)) {
33417     jj_scanpos = xsp;
33418     if (jj_scan_token(189)) {
33419     jj_scanpos = xsp;
33420     if (jj_scan_token(188)) {
33421     jj_scanpos = xsp;
33422     if (jj_scan_token(192)) return true;
33423     }
33424     }
33425     }
33426     }
33427     }
33428     return false;
33429   }
33430 
33431   private boolean jj_3R_594() {
33432     if (jj_3R_173()) return true;
33433     return false;
33434   }
33435 
33436   private boolean jj_3R_641() {
33437     Token xsp;
33438     xsp = jj_scanpos;
33439     if (jj_scan_token(137)) {
33440     jj_scanpos = xsp;
33441     if (jj_scan_token(207)) {
33442     jj_scanpos = xsp;
33443     if (jj_scan_token(138)) return true;
33444     }
33445     }
33446     return false;
33447   }
33448 
33449   private boolean jj_3R_492() {
33450     if (jj_scan_token(NOT)) return true;
33451     if (jj_scan_token(NULL)) return true;
33452     return false;
33453   }
33454 
33455   private boolean jj_3R_520() {
33456     if (jj_scan_token(RANGE)) return true;
33457     if (jj_3R_483()) return true;
33458     if (jj_scan_token(12)) return true;
33459     if (jj_3R_483()) return true;
33460     return false;
33461   }
33462 
33463   private boolean jj_3R_519() {
33464     if (jj_scan_token(5)) return true;
33465     if (jj_scan_token(IDENTIFIER)) return true;
33466     if (jj_scan_token(7)) return true;
33467     return false;
33468   }
33469 
33470   private boolean jj_3R_491() {
33471     Token xsp;
33472     xsp = jj_scanpos;
33473     if (jj_3R_519()) {
33474     jj_scanpos = xsp;
33475     if (jj_3R_520()) return true;
33476     }
33477     return false;
33478   }
33479 
33480   private boolean jj_3R_642() {
33481     if (jj_scan_token(IN)) return true;
33482     Token xsp;
33483     xsp = jj_scanpos;
33484     if (jj_scan_token(207)) jj_scanpos = xsp;
33485     return false;
33486   }
33487 
33488   private boolean jj_3R_639() {
33489     Token xsp;
33490     xsp = jj_scanpos;
33491     if (jj_3R_642()) {
33492     jj_scanpos = xsp;
33493     if (jj_scan_token(207)) return true;
33494     }
33495     return false;
33496   }
33497 
33498   private boolean jj_3R_638() {
33499     if (jj_scan_token(6)) return true;
33500     Token xsp;
33501     xsp = jj_scanpos;
33502     if (jj_3R_641()) jj_scanpos = xsp;
33503     if (jj_3R_233()) return true;
33504     return false;
33505   }
33506 
33507   private boolean jj_3R_243() {
33508     if (jj_scan_token(TYPE)) return true;
33509     if (jj_3R_120()) return true;
33510     Token xsp;
33511     xsp = jj_scanpos;
33512     if (jj_scan_token(152)) {
33513     jj_scanpos = xsp;
33514     if (jj_scan_token(51)) return true;
33515     }
33516     xsp = jj_scanpos;
33517     if (jj_3_44()) {
33518     jj_scanpos = xsp;
33519     if (jj_3R_493()) {
33520     jj_scanpos = xsp;
33521     if (jj_3R_494()) {
33522     jj_scanpos = xsp;
33523     if (jj_3R_495()) {
33524     jj_scanpos = xsp;
33525     if (jj_3R_496()) {
33526     jj_scanpos = xsp;
33527     if (jj_3R_497()) {
33528     jj_scanpos = xsp;
33529     if (jj_3R_498()) return true;
33530     }
33531     }
33532     }
33533     }
33534     }
33535     }
33536     return false;
33537   }
33538 
33539   private boolean jj_3R_636() {
33540     if (jj_scan_token(6)) return true;
33541     if (jj_3R_233()) return true;
33542     return false;
33543   }
33544 
33545   private boolean jj_3R_635() {
33546     if (jj_scan_token(6)) return true;
33547     Token xsp;
33548     xsp = jj_scanpos;
33549     if (jj_3R_639()) jj_scanpos = xsp;
33550     if (jj_3R_233()) return true;
33551     return false;
33552   }
33553 
33554   private boolean jj_3R_242() {
33555     if (jj_scan_token(SUBTYPE)) return true;
33556     if (jj_3R_120()) return true;
33557     if (jj_scan_token(IS)) return true;
33558     if (jj_3R_235()) return true;
33559     Token xsp;
33560     xsp = jj_scanpos;
33561     if (jj_3R_491()) jj_scanpos = xsp;
33562     xsp = jj_scanpos;
33563     if (jj_3R_492()) jj_scanpos = xsp;
33564     return false;
33565   }
33566 
33567   private boolean jj_3R_619() {
33568     if (jj_3R_173()) return true;
33569     return false;
33570   }
33571 
33572   private boolean jj_3R_152() {
33573     Token xsp;
33574     xsp = jj_scanpos;
33575     if (jj_3R_242()) {
33576     jj_scanpos = xsp;
33577     if (jj_3R_243()) return true;
33578     }
33579     if (jj_scan_token(4)) return true;
33580     return false;
33581   }
33582 
33583   private boolean jj_3R_555() {
33584     if (jj_scan_token(LIMIT)) return true;
33585     if (jj_3R_233()) return true;
33586     return false;
33587   }
33588 
33589   private boolean jj_3R_596() {
33590     if (jj_scan_token(CC_ELSE)) return true;
33591     Token xsp;
33592     if (jj_3R_619()) return true;
33593     while (true) {
33594       xsp = jj_scanpos;
33595       if (jj_3R_619()) { jj_scanpos = xsp; break; }
33596     }
33597     return false;
33598   }
33599 
33600   private boolean jj_3R_595() {
33601     if (jj_scan_token(CC_ELSIF)) return true;
33602     if (jj_3R_343()) return true;
33603     if (jj_scan_token(CC_THEN)) return true;
33604     Token xsp;
33605     if (jj_3R_640()) return true;
33606     while (true) {
33607       xsp = jj_scanpos;
33608       if (jj_3R_640()) { jj_scanpos = xsp; break; }
33609     }
33610     return false;
33611   }
33612 
33613   private boolean jj_3R_456() {
33614     if (jj_scan_token(CC_ERROR)) return true;
33615     if (jj_3R_233()) return true;
33616     if (jj_scan_token(CC_END)) return true;
33617     return false;
33618   }
33619 
33620   private boolean jj_3R_455() {
33621     if (jj_scan_token(CC_IF)) return true;
33622     if (jj_3R_343()) return true;
33623     if (jj_scan_token(CC_THEN)) return true;
33624     Token xsp;
33625     while (true) {
33626       xsp = jj_scanpos;
33627       if (jj_3R_594()) { jj_scanpos = xsp; break; }
33628     }
33629     while (true) {
33630       xsp = jj_scanpos;
33631       if (jj_3R_595()) { jj_scanpos = xsp; break; }
33632     }
33633     while (true) {
33634       xsp = jj_scanpos;
33635       if (jj_3R_596()) { jj_scanpos = xsp; break; }
33636     }
33637     if (jj_scan_token(CC_END)) return true;
33638     return false;
33639   }
33640 
33641   private boolean jj_3R_617() {
33642     Token xsp;
33643     xsp = jj_scanpos;
33644     if (jj_scan_token(137)) {
33645     jj_scanpos = xsp;
33646     if (jj_scan_token(207)) {
33647     jj_scanpos = xsp;
33648     if (jj_scan_token(138)) return true;
33649     }
33650     }
33651     return false;
33652   }
33653 
33654   private boolean jj_3R_634() {
33655     if (jj_scan_token(6)) return true;
33656     if (jj_3R_294()) return true;
33657     return false;
33658   }
33659 
33660   private boolean jj_3R_420() {
33661     Token xsp;
33662     xsp = jj_scanpos;
33663     if (jj_3R_455()) {
33664     jj_scanpos = xsp;
33665     if (jj_3R_456()) return true;
33666     }
33667     return false;
33668   }
33669 
33670   private boolean jj_3R_618() {
33671     if (jj_scan_token(IN)) return true;
33672     Token xsp;
33673     xsp = jj_scanpos;
33674     if (jj_scan_token(207)) jj_scanpos = xsp;
33675     return false;
33676   }
33677 
33678   private boolean jj_3R_593() {
33679     Token xsp;
33680     xsp = jj_scanpos;
33681     if (jj_3R_618()) {
33682     jj_scanpos = xsp;
33683     if (jj_scan_token(207)) return true;
33684     }
33685     return false;
33686   }
33687 
33688   private boolean jj_3R_553() {
33689     if (jj_scan_token(BULK)) return true;
33690     if (jj_scan_token(COLLECT)) return true;
33691     return false;
33692   }
33693 
33694   private boolean jj_3R_554() {
33695     if (jj_scan_token(6)) return true;
33696     if (jj_3R_233()) return true;
33697     return false;
33698   }
33699 
33700   private boolean jj_3R_419() {
33701     if (jj_scan_token(PIPE)) return true;
33702     if (jj_scan_token(ROW)) return true;
33703     if (jj_3R_233()) return true;
33704     return false;
33705   }
33706 
33707   private boolean jj_3R_592() {
33708     if (jj_scan_token(USING)) return true;
33709     Token xsp;
33710     xsp = jj_scanpos;
33711     if (jj_3R_617()) jj_scanpos = xsp;
33712     if (jj_3R_233()) return true;
33713     while (true) {
33714       xsp = jj_scanpos;
33715       if (jj_3R_638()) { jj_scanpos = xsp; break; }
33716     }
33717     return false;
33718   }
33719 
33720   private boolean jj_3R_558() {
33721     Token xsp;
33722     xsp = jj_scanpos;
33723     if (jj_scan_token(237)) {
33724     jj_scanpos = xsp;
33725     if (jj_scan_token(238)) return true;
33726     }
33727     if (jj_scan_token(INTO)) return true;
33728     if (jj_3R_233()) return true;
33729     while (true) {
33730       xsp = jj_scanpos;
33731       if (jj_3R_636()) { jj_scanpos = xsp; break; }
33732     }
33733     return false;
33734   }
33735 
33736   private boolean jj_3R_557() {
33737     if (jj_scan_token(USING)) return true;
33738     Token xsp;
33739     xsp = jj_scanpos;
33740     if (jj_3R_593()) jj_scanpos = xsp;
33741     if (jj_3R_233()) return true;
33742     while (true) {
33743       xsp = jj_scanpos;
33744       if (jj_3R_635()) { jj_scanpos = xsp; break; }
33745     }
33746     return false;
33747   }
33748 
33749   private boolean jj_3R_556() {
33750     if (jj_scan_token(INTO)) return true;
33751     if (jj_3R_294()) return true;
33752     Token xsp;
33753     while (true) {
33754       xsp = jj_scanpos;
33755       if (jj_3R_634()) { jj_scanpos = xsp; break; }
33756     }
33757     return false;
33758   }
33759 
33760   private boolean jj_3R_403() {
33761     if (jj_scan_token(INTERFACE)) return true;
33762     if (jj_scan_token(5)) return true;
33763     return false;
33764   }
33765 
33766   private boolean jj_3R_402() {
33767     if (jj_scan_token(EXCEPTION_INIT)) return true;
33768     if (jj_scan_token(5)) return true;
33769     return false;
33770   }
33771 
33772   private boolean jj_3R_401() {
33773     if (jj_scan_token(RESTRICT_REFERENCES)) return true;
33774     if (jj_scan_token(5)) return true;
33775     return false;
33776   }
33777 
33778   private boolean jj_3R_451() {
33779     if (jj_scan_token(WHEN)) return true;
33780     if (jj_3R_233()) return true;
33781     return false;
33782   }
33783 
33784   private boolean jj_3R_418() {
33785     if (jj_scan_token(EXECUTE)) return true;
33786     if (jj_scan_token(IMMEDIATE)) return true;
33787     if (jj_3R_233()) return true;
33788     Token xsp;
33789     xsp = jj_scanpos;
33790     if (jj_3R_556()) jj_scanpos = xsp;
33791     xsp = jj_scanpos;
33792     if (jj_3R_557()) jj_scanpos = xsp;
33793     xsp = jj_scanpos;
33794     if (jj_3R_558()) jj_scanpos = xsp;
33795     if (jj_scan_token(4)) return true;
33796     return false;
33797   }
33798 
33799   private boolean jj_3R_454() {
33800     if (jj_scan_token(FOR)) return true;
33801     if (jj_3R_233()) return true;
33802     Token xsp;
33803     xsp = jj_scanpos;
33804     if (jj_3R_592()) jj_scanpos = xsp;
33805     return false;
33806   }
33807 
33808   private boolean jj_3R_417() {
33809     if (jj_scan_token(FETCH)) return true;
33810     if (jj_3R_128()) return true;
33811     Token xsp;
33812     xsp = jj_scanpos;
33813     if (jj_3R_553()) jj_scanpos = xsp;
33814     if (jj_scan_token(INTO)) return true;
33815     if (jj_3R_233()) return true;
33816     while (true) {
33817       xsp = jj_scanpos;
33818       if (jj_3R_554()) { jj_scanpos = xsp; break; }
33819     }
33820     xsp = jj_scanpos;
33821     if (jj_3R_555()) jj_scanpos = xsp;
33822     return false;
33823   }
33824 
33825   private boolean jj_3R_208() {
33826     if (jj_scan_token(WHEN)) return true;
33827     if (jj_3R_233()) return true;
33828     return false;
33829   }
33830 
33831   private boolean jj_3R_453() {
33832     if (jj_3R_233()) return true;
33833     return false;
33834   }
33835 
33836   private boolean jj_3R_351() {
33837     if (jj_scan_token(PRAGMA)) return true;
33838     Token xsp;
33839     xsp = jj_scanpos;
33840     if (jj_scan_token(38)) {
33841     jj_scanpos = xsp;
33842     if (jj_scan_token(41)) {
33843     jj_scanpos = xsp;
33844     if (jj_3R_401()) {
33845     jj_scanpos = xsp;
33846     if (jj_3R_402()) {
33847     jj_scanpos = xsp;
33848     if (jj_3R_403()) return true;
33849     }
33850     }
33851     }
33852     }
33853     return false;
33854   }
33855 
33856   private boolean jj_3R_416() {
33857     if (jj_scan_token(OPEN)) return true;
33858     Token xsp;
33859     xsp = jj_scanpos;
33860     if (jj_3R_453()) jj_scanpos = xsp;
33861     xsp = jj_scanpos;
33862     if (jj_3R_454()) jj_scanpos = xsp;
33863     return false;
33864   }
33865 
33866   private boolean jj_3R_452() {
33867     if (jj_3R_128()) return true;
33868     return false;
33869   }
33870 
33871   private boolean jj_3R_415() {
33872     if (jj_scan_token(CLOSE)) return true;
33873     if (jj_3R_128()) return true;
33874     return false;
33875   }
33876 
33877   private boolean jj_3R_450() {
33878     if (jj_3R_142()) return true;
33879     return false;
33880   }
33881 
33882   private boolean jj_3R_414() {
33883     if (jj_scan_token(RAISE)) return true;
33884     Token xsp;
33885     xsp = jj_scanpos;
33886     if (jj_3R_452()) jj_scanpos = xsp;
33887     return false;
33888   }
33889 
33890   private boolean jj_3R_207() {
33891     if (jj_3R_142()) return true;
33892     return false;
33893   }
33894 
33895   private boolean jj_3R_147() {
33896     if (jj_3R_124()) return true;
33897     if (jj_3R_235()) return true;
33898     return false;
33899   }
33900 
33901   private boolean jj_3R_591() {
33902     if (jj_scan_token(12)) return true;
33903     if (jj_3R_233()) return true;
33904     return false;
33905   }
33906 
33907   private boolean jj_3R_413() {
33908     if (jj_scan_token(EXIT)) return true;
33909     Token xsp;
33910     xsp = jj_scanpos;
33911     if (jj_3R_450()) jj_scanpos = xsp;
33912     xsp = jj_scanpos;
33913     if (jj_3R_451()) jj_scanpos = xsp;
33914     return false;
33915   }
33916 
33917   private boolean jj_3R_449() {
33918     if (jj_3R_233()) return true;
33919     return false;
33920   }
33921 
33922   private boolean jj_3R_132() {
33923     if (jj_scan_token(CONTINUE)) return true;
33924     Token xsp;
33925     xsp = jj_scanpos;
33926     if (jj_3R_207()) jj_scanpos = xsp;
33927     xsp = jj_scanpos;
33928     if (jj_3R_208()) jj_scanpos = xsp;
33929     return false;
33930   }
33931 
33932   private boolean jj_3R_551() {
33933     if (jj_scan_token(SAVE)) return true;
33934     if (jj_scan_token(EXCEPTIONS)) return true;
33935     return false;
33936   }
33937 
33938   private boolean jj_3R_550() {
33939     if (jj_3R_233()) return true;
33940     Token xsp;
33941     xsp = jj_scanpos;
33942     if (jj_3R_591()) jj_scanpos = xsp;
33943     return false;
33944   }
33945 
33946   private boolean jj_3R_633() {
33947     if (jj_3R_173()) return true;
33948     return false;
33949   }
33950 
33951   private boolean jj_3R_549() {
33952     Token xsp;
33953     xsp = jj_scanpos;
33954     if (jj_scan_token(140)) {
33955     jj_scanpos = xsp;
33956     if (jj_scan_token(289)) return true;
33957     }
33958     if (jj_scan_token(OF)) return true;
33959     if (jj_3R_233()) return true;
33960     return false;
33961   }
33962 
33963   private boolean jj_3R_412() {
33964     if (jj_scan_token(RETURN)) return true;
33965     Token xsp;
33966     xsp = jj_scanpos;
33967     if (jj_3R_449()) jj_scanpos = xsp;
33968     return false;
33969   }
33970 
33971   private boolean jj_3R_411() {
33972     if (jj_scan_token(GOTO)) return true;
33973     if (jj_3R_128()) return true;
33974     return false;
33975   }
33976 
33977   private boolean jj_3R_408() {
33978     if (jj_scan_token(FORALL)) return true;
33979     if (jj_3R_447()) return true;
33980     if (jj_scan_token(IN)) return true;
33981     Token xsp;
33982     xsp = jj_scanpos;
33983     if (jj_3R_549()) {
33984     jj_scanpos = xsp;
33985     if (jj_3R_550()) return true;
33986     }
33987     xsp = jj_scanpos;
33988     if (jj_3R_551()) jj_scanpos = xsp;
33989     if (jj_3R_404()) return true;
33990     return false;
33991   }
33992 
33993   private boolean jj_3R_548() {
33994     if (jj_scan_token(12)) return true;
33995     if (jj_3R_233()) return true;
33996     return false;
33997   }
33998 
33999   private boolean jj_3R_545() {
34000     if (jj_3R_173()) return true;
34001     return false;
34002   }
34003 
34004   private boolean jj_3R_355() {
34005     if (jj_scan_token(CASCADE)) return true;
34006     return false;
34007   }
34008 
34009   private boolean jj_3R_552() {
34010     if (jj_3R_173()) return true;
34011     return false;
34012   }
34013 
34014   private boolean jj_3R_447() {
34015     if (jj_3R_124()) return true;
34016     return false;
34017   }
34018 
34019   private boolean jj_3R_314() {
34020     Token xsp;
34021     xsp = jj_scanpos;
34022     if (jj_scan_token(151)) {
34023     jj_scanpos = xsp;
34024     if (jj_3R_355()) return true;
34025     }
34026     return false;
34027   }
34028 
34029   private boolean jj_3R_149() {
34030     if (jj_3R_238()) return true;
34031     return false;
34032   }
34033 
34034   private boolean jj_3_72() {
34035     if (jj_3R_146()) return true;
34036     return false;
34037   }
34038 
34039   private boolean jj_3R_148() {
34040     if (jj_scan_token(AUTHID)) return true;
34041     Token xsp;
34042     xsp = jj_scanpos;
34043     if (jj_scan_token(37)) {
34044     jj_scanpos = xsp;
34045     if (jj_scan_token(36)) return true;
34046     }
34047     return false;
34048   }
34049 
34050   private boolean jj_3R_446() {
34051     if (jj_3R_124()) return true;
34052     return false;
34053   }
34054 
34055   private boolean jj_3R_313() {
34056     Token xsp;
34057     xsp = jj_scanpos;
34058     if (jj_scan_token(183)) jj_scanpos = xsp;
34059     xsp = jj_scanpos;
34060     if (jj_scan_token(119)) {
34061     jj_scanpos = xsp;
34062     if (jj_scan_token(145)) {
34063     jj_scanpos = xsp;
34064     if (jj_scan_token(185)) return true;
34065     }
34066     }
34067     return false;
34068   }
34069 
34070   private boolean jj_3_71() {
34071     if (jj_3R_146()) return true;
34072     return false;
34073   }
34074 
34075   private boolean jj_3R_547() {
34076     if (jj_3R_485()) return true;
34077     return false;
34078   }
34079 
34080   private boolean jj_3R_546() {
34081     if (jj_3R_590()) return true;
34082     return false;
34083   }
34084 
34085   private boolean jj_3R_406() {
34086     if (jj_scan_token(IF)) return true;
34087     if (jj_3R_233()) return true;
34088     if (jj_scan_token(THEN)) return true;
34089     Token xsp;
34090     if (jj_3R_545()) return true;
34091     while (true) {
34092       xsp = jj_scanpos;
34093       if (jj_3R_545()) { jj_scanpos = xsp; break; }
34094     }
34095     while (true) {
34096       xsp = jj_scanpos;
34097       if (jj_3R_546()) { jj_scanpos = xsp; break; }
34098     }
34099     xsp = jj_scanpos;
34100     if (jj_3R_547()) jj_scanpos = xsp;
34101     if (jj_scan_token(END)) return true;
34102     if (jj_scan_token(IF)) return true;
34103     return false;
34104   }
34105 
34106   private boolean jj_3R_637() {
34107     if (jj_3R_173()) return true;
34108     return false;
34109   }
34110 
34111   private boolean jj_3R_410() {
34112     if (jj_scan_token(WHILE)) return true;
34113     if (jj_3R_233()) return true;
34114     if (jj_scan_token(LOOP)) return true;
34115     Token xsp;
34116     if (jj_3R_552()) return true;
34117     while (true) {
34118       xsp = jj_scanpos;
34119       if (jj_3R_552()) { jj_scanpos = xsp; break; }
34120     }
34121     if (jj_scan_token(END)) return true;
34122     if (jj_scan_token(LOOP)) return true;
34123     xsp = jj_scanpos;
34124     if (jj_scan_token(420)) jj_scanpos = xsp;
34125     return false;
34126   }
34127 
34128   private boolean jj_3R_131() {
34129     if (jj_scan_token(LOCK)) return true;
34130     if (jj_scan_token(TABLE)) return true;
34131     return false;
34132   }
34133 
34134   private boolean jj_3_70() {
34135     Token xsp;
34136     xsp = jj_scanpos;
34137     if (jj_3R_148()) {
34138     jj_scanpos = xsp;
34139     if (jj_3R_149()) return true;
34140     }
34141     return false;
34142   }
34143 
34144   private boolean jj_3R_312() {
34145     if (jj_scan_token(REPLACE)) return true;
34146     return false;
34147   }
34148 
34149   private boolean jj_3R_407() {
34150     if (jj_scan_token(FOR)) return true;
34151     if (jj_3R_446()) return true;
34152     if (jj_scan_token(IN)) return true;
34153     Token xsp;
34154     xsp = jj_scanpos;
34155     if (jj_scan_token(239)) jj_scanpos = xsp;
34156     if (jj_3R_233()) return true;
34157     xsp = jj_scanpos;
34158     if (jj_3R_548()) jj_scanpos = xsp;
34159     if (jj_scan_token(LOOP)) return true;
34160     if (jj_3R_633()) return true;
34161     while (true) {
34162       xsp = jj_scanpos;
34163       if (jj_3R_633()) { jj_scanpos = xsp; break; }
34164     }
34165     if (jj_scan_token(END)) return true;
34166     if (jj_scan_token(LOOP)) return true;
34167     xsp = jj_scanpos;
34168     if (jj_scan_token(420)) jj_scanpos = xsp;
34169     return false;
34170   }
34171 
34172   private boolean jj_3R_615() {
34173     if (jj_3R_173()) return true;
34174     return false;
34175   }
34176 
34177   private boolean jj_3R_448() {
34178     if (jj_3R_173()) return true;
34179     return false;
34180   }
34181 
34182   private boolean jj_3R_409() {
34183     if (jj_scan_token(LOOP)) return true;
34184     Token xsp;
34185     if (jj_3R_448()) return true;
34186     while (true) {
34187       xsp = jj_scanpos;
34188       if (jj_3R_448()) { jj_scanpos = xsp; break; }
34189     }
34190     if (jj_scan_token(END)) return true;
34191     if (jj_scan_token(LOOP)) return true;
34192     xsp = jj_scanpos;
34193     if (jj_scan_token(420)) jj_scanpos = xsp;
34194     return false;
34195   }
34196 
34197   private boolean jj_3R_130() {
34198     if (jj_scan_token(SET)) return true;
34199     if (jj_scan_token(TRANSACTION)) return true;
34200     return false;
34201   }
34202 
34203   private boolean jj_3R_616() {
34204     if (jj_3R_173()) return true;
34205     return false;
34206   }
34207 
34208   private boolean jj_3R_590() {
34209     if (jj_scan_token(ELSIF)) return true;
34210     if (jj_3R_233()) return true;
34211     if (jj_scan_token(THEN)) return true;
34212     Token xsp;
34213     if (jj_3R_637()) return true;
34214     while (true) {
34215       xsp = jj_scanpos;
34216       if (jj_3R_637()) { jj_scanpos = xsp; break; }
34217     }
34218     return false;
34219   }
34220 
34221   private boolean jj_3R_485() {
34222     if (jj_scan_token(ELSE)) return true;
34223     Token xsp;
34224     if (jj_3R_616()) return true;
34225     while (true) {
34226       xsp = jj_scanpos;
34227       if (jj_3R_616()) { jj_scanpos = xsp; break; }
34228     }
34229     return false;
34230   }
34231 
34232   private boolean jj_3R_484() {
34233     if (jj_scan_token(WHEN)) return true;
34234     if (jj_3R_233()) return true;
34235     if (jj_scan_token(THEN)) return true;
34236     Token xsp;
34237     if (jj_3R_615()) return true;
34238     while (true) {
34239       xsp = jj_scanpos;
34240       if (jj_3R_615()) { jj_scanpos = xsp; break; }
34241     }
34242     return false;
34243   }
34244 
34245   private boolean jj_3R_443() {
34246     if (jj_3R_233()) return true;
34247     return false;
34248   }
34249 
34250   private boolean jj_3R_445() {
34251     if (jj_3R_485()) return true;
34252     return false;
34253   }
34254 
34255   private boolean jj_3R_444() {
34256     if (jj_3R_484()) return true;
34257     return false;
34258   }
34259 
34260   private boolean jj_3R_405() {
34261     if (jj_scan_token(CASE)) return true;
34262     Token xsp;
34263     xsp = jj_scanpos;
34264     if (jj_3R_443()) jj_scanpos = xsp;
34265     while (true) {
34266       xsp = jj_scanpos;
34267       if (jj_3R_444()) { jj_scanpos = xsp; break; }
34268     }
34269     xsp = jj_scanpos;
34270     if (jj_3R_445()) jj_scanpos = xsp;
34271     if (jj_scan_token(END)) return true;
34272     if (jj_scan_token(CASE)) return true;
34273     xsp = jj_scanpos;
34274     if (jj_scan_token(420)) jj_scanpos = xsp;
34275     return false;
34276   }
34277 
34278   private boolean jj_3R_356() {
34279     if (jj_3R_190()) return true;
34280     return false;
34281   }
34282 
34283   private boolean jj_3R_354() {
34284     if (jj_scan_token(DROP)) return true;
34285     return false;
34286   }
34287 
34288   private boolean jj_3R_315() {
34289     Token xsp;
34290     if (jj_3R_356()) return true;
34291     while (true) {
34292       xsp = jj_scanpos;
34293       if (jj_3R_356()) { jj_scanpos = xsp; break; }
34294     }
34295     if (jj_3R_316()) return true;
34296     return false;
34297   }
34298 
34299   private boolean jj_3R_264() {
34300     if (jj_3R_316()) return true;
34301     return false;
34302   }
34303 
34304   private boolean jj_3R_263() {
34305     if (jj_3R_315()) return true;
34306     return false;
34307   }
34308 
34309   private boolean jj_3R_353() {
34310     Token xsp;
34311     xsp = jj_scanpos;
34312     if (jj_scan_token(6)) jj_scanpos = xsp;
34313     xsp = jj_scanpos;
34314     if (jj_scan_token(44)) {
34315     jj_scanpos = xsp;
34316     if (jj_scan_token(170)) return true;
34317     }
34318     return false;
34319   }
34320 
34321   private boolean jj_3R_311() {
34322     Token xsp;
34323     xsp = jj_scanpos;
34324     if (jj_3R_353()) {
34325     jj_scanpos = xsp;
34326     if (jj_3R_354()) return true;
34327     }
34328     return false;
34329   }
34330 
34331   private boolean jj_3R_173() {
34332     Token xsp;
34333     xsp = jj_scanpos;
34334     if (jj_3R_263()) {
34335     jj_scanpos = xsp;
34336     if (jj_3R_264()) return true;
34337     }
34338     return false;
34339   }
34340 
34341   private boolean jj_3R_376() {
34342     if (jj_3R_233()) return true;
34343     if (jj_scan_token(4)) return true;
34344     return false;
34345   }
34346 
34347   private boolean jj_3R_375() {
34348     if (jj_3R_421()) return true;
34349     if (jj_scan_token(4)) return true;
34350     return false;
34351   }
34352 
34353   private boolean jj_3R_374() {
34354     if (jj_3R_420()) return true;
34355     return false;
34356   }
34357 
34358   private boolean jj_3R_373() {
34359     if (jj_3R_419()) return true;
34360     if (jj_scan_token(4)) return true;
34361     return false;
34362   }
34363 
34364   private boolean jj_3R_307() {
34365     if (jj_3R_147()) return true;
34366     return false;
34367   }
34368 
34369   private boolean jj_3R_442() {
34370     if (jj_scan_token(LOCK)) return true;
34371     if (jj_scan_token(TABLE)) return true;
34372     return false;
34373   }
34374 
34375   private boolean jj_3R_372() {
34376     if (jj_3R_418()) return true;
34377     if (jj_scan_token(4)) return true;
34378     return false;
34379   }
34380 
34381   private boolean jj_3R_259() {
34382     if (jj_scan_token(ALTER)) return true;
34383     if (jj_scan_token(TYPE)) return true;
34384     if (jj_3R_128()) return true;
34385     Token xsp;
34386     while (true) {
34387       xsp = jj_scanpos;
34388       if (jj_3R_311()) { jj_scanpos = xsp; break; }
34389     }
34390     xsp = jj_scanpos;
34391     if (jj_3R_312()) jj_scanpos = xsp;
34392     while (true) {
34393       xsp = jj_scanpos;
34394       if (jj_3R_313()) { jj_scanpos = xsp; break; }
34395     }
34396     xsp = jj_scanpos;
34397     if (jj_3R_314()) jj_scanpos = xsp;
34398     return false;
34399   }
34400 
34401   private boolean jj_3R_371() {
34402     if (jj_3R_271()) return true;
34403     if (jj_scan_token(4)) return true;
34404     return false;
34405   }
34406 
34407   private boolean jj_3R_370() {
34408     if (jj_3R_417()) return true;
34409     if (jj_scan_token(4)) return true;
34410     return false;
34411   }
34412 
34413   private boolean jj_3_69() {
34414     if (jj_3R_147()) return true;
34415     return false;
34416   }
34417 
34418   private boolean jj_3R_369() {
34419     if (jj_3R_416()) return true;
34420     if (jj_scan_token(4)) return true;
34421     return false;
34422   }
34423 
34424   private boolean jj_3R_368() {
34425     if (jj_3R_415()) return true;
34426     if (jj_scan_token(4)) return true;
34427     return false;
34428   }
34429 
34430   private boolean jj_3R_367() {
34431     if (jj_3R_414()) return true;
34432     if (jj_scan_token(4)) return true;
34433     return false;
34434   }
34435 
34436   private boolean jj_3R_366() {
34437     if (jj_3R_413()) return true;
34438     if (jj_scan_token(4)) return true;
34439     return false;
34440   }
34441 
34442   private boolean jj_3R_365() {
34443     if (jj_3R_412()) return true;
34444     if (jj_scan_token(4)) return true;
34445     return false;
34446   }
34447 
34448   private boolean jj_3R_364() {
34449     if (jj_3R_411()) return true;
34450     if (jj_scan_token(4)) return true;
34451     return false;
34452   }
34453 
34454   private boolean jj_3_42() {
34455     Token xsp;
34456     xsp = jj_scanpos;
34457     if (jj_3R_129()) {
34458     jj_scanpos = xsp;
34459     if (jj_scan_token(297)) {
34460     jj_scanpos = xsp;
34461     if (jj_scan_token(144)) {
34462     jj_scanpos = xsp;
34463     if (jj_scan_token(93)) {
34464     jj_scanpos = xsp;
34465     if (jj_scan_token(76)) {
34466     jj_scanpos = xsp;
34467     if (jj_scan_token(241)) {
34468     jj_scanpos = xsp;
34469     if (jj_scan_token(248)) {
34470     jj_scanpos = xsp;
34471     if (jj_scan_token(111)) {
34472     jj_scanpos = xsp;
34473     if (jj_3R_130()) {
34474     jj_scanpos = xsp;
34475     if (jj_3R_131()) {
34476     jj_scanpos = xsp;
34477     if (jj_scan_token(165)) {
34478     jj_scanpos = xsp;
34479     if (jj_scan_token(318)) return true;
34480     }
34481     }
34482     }
34483     }
34484     }
34485     }
34486     }
34487     }
34488     }
34489     }
34490     }
34491     return false;
34492   }
34493 
34494   private boolean jj_3R_129() {
34495     Token xsp;
34496     xsp = jj_scanpos;
34497     if (jj_scan_token(5)) jj_scanpos = xsp;
34498     if (jj_scan_token(SELECT)) return true;
34499     return false;
34500   }
34501 
34502   private boolean jj_3R_363() {
34503     if (jj_3R_410()) return true;
34504     if (jj_scan_token(4)) return true;
34505     return false;
34506   }
34507 
34508   private boolean jj_3R_362() {
34509     if (jj_3R_409()) return true;
34510     if (jj_scan_token(4)) return true;
34511     return false;
34512   }
34513 
34514   private boolean jj_3R_260() {
34515     if (jj_3R_259()) return true;
34516     return false;
34517   }
34518 
34519   private boolean jj_3R_361() {
34520     if (jj_3R_408()) return true;
34521     if (jj_scan_token(4)) return true;
34522     return false;
34523   }
34524 
34525   private boolean jj_3R_360() {
34526     if (jj_3R_407()) return true;
34527     if (jj_scan_token(4)) return true;
34528     return false;
34529   }
34530 
34531   private boolean jj_3R_359() {
34532     if (jj_3R_406()) return true;
34533     if (jj_scan_token(4)) return true;
34534     return false;
34535   }
34536 
34537   private boolean jj_3R_167() {
34538     Token xsp;
34539     xsp = jj_scanpos;
34540     if (jj_scan_token(4)) {
34541     jj_scanpos = xsp;
34542     if (jj_scan_token(1)) return true;
34543     }
34544     while (true) {
34545       xsp = jj_scanpos;
34546       if (jj_3R_260()) { jj_scanpos = xsp; break; }
34547     }
34548     return false;
34549   }
34550 
34551   private boolean jj_3R_358() {
34552     if (jj_3R_405()) return true;
34553     if (jj_scan_token(4)) return true;
34554     return false;
34555   }
34556 
34557   private boolean jj_3_43() {
34558     if (jj_3R_132()) return true;
34559     if (jj_scan_token(4)) return true;
34560     return false;
34561   }
34562 
34563   private boolean jj_3R_166() {
34564     if (jj_3R_259()) return true;
34565     return false;
34566   }
34567 
34568   private boolean jj_3R_309() {
34569     if (jj_3R_146()) return true;
34570     return false;
34571   }
34572 
34573   private boolean jj_3R_310() {
34574     if (jj_3R_351()) return true;
34575     return false;
34576   }
34577 
34578   private boolean jj_3R_357() {
34579     if (jj_3R_404()) return true;
34580     Token xsp;
34581     xsp = jj_scanpos;
34582     if (jj_scan_token(4)) jj_scanpos = xsp;
34583     return false;
34584   }
34585 
34586   private boolean jj_3R_441() {
34587     if (jj_scan_token(SET)) return true;
34588     if (jj_scan_token(TRANSACTION)) return true;
34589     return false;
34590   }
34591 
34592   private boolean jj_3R_316() {
34593     Token xsp;
34594     xsp = jj_scanpos;
34595     if (jj_3R_357()) {
34596     jj_scanpos = xsp;
34597     if (jj_3_43()) {
34598     jj_scanpos = xsp;
34599     if (jj_3R_358()) {
34600     jj_scanpos = xsp;
34601     if (jj_3R_359()) {
34602     jj_scanpos = xsp;
34603     if (jj_3R_360()) {
34604     jj_scanpos = xsp;
34605     if (jj_3R_361()) {
34606     jj_scanpos = xsp;
34607     if (jj_3R_362()) {
34608     jj_scanpos = xsp;
34609     if (jj_3R_363()) {
34610     jj_scanpos = xsp;
34611     if (jj_3R_364()) {
34612     jj_scanpos = xsp;
34613     if (jj_3R_365()) {
34614     jj_scanpos = xsp;
34615     if (jj_3R_366()) {
34616     jj_scanpos = xsp;
34617     if (jj_3R_367()) {
34618     jj_scanpos = xsp;
34619     if (jj_3R_368()) {
34620     jj_scanpos = xsp;
34621     if (jj_3R_369()) {
34622     jj_scanpos = xsp;
34623     if (jj_3R_370()) {
34624     jj_scanpos = xsp;
34625     if (jj_3R_371()) {
34626     jj_scanpos = xsp;
34627     if (jj_3R_372()) {
34628     jj_scanpos = xsp;
34629     if (jj_3R_373()) {
34630     jj_scanpos = xsp;
34631     if (jj_3R_374()) {
34632     jj_scanpos = xsp;
34633     if (jj_3R_375()) {
34634     jj_scanpos = xsp;
34635     if (jj_3R_376()) return true;
34636     }
34637     }
34638     }
34639     }
34640     }
34641     }
34642     }
34643     }
34644     }
34645     }
34646     }
34647     }
34648     }
34649     }
34650     }
34651     }
34652     }
34653     }
34654     }
34655     }
34656     return false;
34657   }
34658 
34659   private boolean jj_3R_165() {
34660     Token xsp;
34661     xsp = jj_scanpos;
34662     if (jj_scan_token(183)) jj_scanpos = xsp;
34663     xsp = jj_scanpos;
34664     if (jj_scan_token(119)) {
34665     jj_scanpos = xsp;
34666     if (jj_scan_token(145)) {
34667     jj_scanpos = xsp;
34668     if (jj_scan_token(185)) return true;
34669     }
34670     }
34671     return false;
34672   }
34673 
34674   private boolean jj_3R_258() {
34675     if (jj_scan_token(6)) return true;
34676     Token xsp;
34677     xsp = jj_scanpos;
34678     if (jj_3R_309()) {
34679     jj_scanpos = xsp;
34680     if (jj_3_69()) {
34681     jj_scanpos = xsp;
34682     if (jj_3R_310()) return true;
34683     }
34684     }
34685     return false;
34686   }
34687 
34688   private boolean jj_3R_308() {
34689     if (jj_3R_351()) return true;
34690     return false;
34691   }
34692 
34693   private boolean jj_3_68() {
34694     if (jj_3R_146()) return true;
34695     return false;
34696   }
34697 
34698   private boolean jj_3R_257() {
34699     Token xsp;
34700     xsp = jj_scanpos;
34701     if (jj_3_68()) {
34702     jj_scanpos = xsp;
34703     if (jj_3R_307()) {
34704     jj_scanpos = xsp;
34705     if (jj_3R_308()) return true;
34706     }
34707     }
34708     return false;
34709   }
34710 
34711   private boolean jj_3R_164() {
34712     if (jj_scan_token(5)) return true;
34713     Token xsp;
34714     while (true) {
34715       xsp = jj_scanpos;
34716       if (jj_3R_257()) { jj_scanpos = xsp; break; }
34717     }
34718     while (true) {
34719       xsp = jj_scanpos;
34720       if (jj_3R_258()) { jj_scanpos = xsp; break; }
34721     }
34722     if (jj_scan_token(7)) return true;
34723     return false;
34724   }
34725 
34726   private boolean jj_3R_603() {
34727     if (jj_3R_124()) return true;
34728     return false;
34729   }
34730 
34731   private boolean jj_3R_163() {
34732     if (jj_3R_248()) return true;
34733     return false;
34734   }
34735 
34736   private boolean jj_3_66() {
34737     Token xsp;
34738     xsp = jj_scanpos;
34739     if (jj_scan_token(152)) {
34740     jj_scanpos = xsp;
34741     if (jj_scan_token(51)) return true;
34742     }
34743     if (jj_3R_145()) return true;
34744     if (jj_scan_token(OF)) return true;
34745     if (jj_3R_235()) return true;
34746     return false;
34747   }
34748 
34749   private boolean jj_3R_144() {
34750     if (jj_3R_238()) return true;
34751     return false;
34752   }
34753 
34754   private boolean jj_3R_248() {
34755     if (jj_scan_token(WRAPPED)) return true;
34756     return false;
34757   }
34758 
34759   private boolean jj_3_65() {
34760     Token xsp;
34761     xsp = jj_scanpos;
34762     if (jj_scan_token(152)) {
34763     jj_scanpos = xsp;
34764     if (jj_scan_token(51)) return true;
34765     }
34766     if (jj_scan_token(OPAQUE)) return true;
34767     if (jj_scan_token(VARYING)) return true;
34768     if (jj_scan_token(24)) return true;
34769     return false;
34770   }
34771 
34772   private boolean jj_3_67() {
34773     if (jj_scan_token(EXTERNAL)) return true;
34774     if (jj_scan_token(IDENTIFIER)) return true;
34775     if (jj_scan_token(IDENTIFIER)) return true;
34776     if (jj_scan_token(LANGUAGE)) return true;
34777     if (jj_scan_token(JAVA)) return true;
34778     if (jj_scan_token(USING)) return true;
34779     if (jj_scan_token(IDENTIFIER)) return true;
34780     return false;
34781   }
34782 
34783   private boolean jj_3_64() {
34784     Token xsp;
34785     xsp = jj_scanpos;
34786     if (jj_scan_token(152)) {
34787     jj_scanpos = xsp;
34788     if (jj_scan_token(51)) return true;
34789     }
34790     if (jj_scan_token(OBJECT)) return true;
34791     return false;
34792   }
34793 
34794   private boolean jj_3R_143() {
34795     if (jj_scan_token(AUTHID)) return true;
34796     Token xsp;
34797     xsp = jj_scanpos;
34798     if (jj_scan_token(37)) {
34799     jj_scanpos = xsp;
34800     if (jj_scan_token(36)) return true;
34801     }
34802     return false;
34803   }
34804 
34805   private boolean jj_3R_256() {
34806     if (jj_scan_token(UNDER)) return true;
34807     if (jj_3R_154()) return true;
34808     return false;
34809   }
34810 
34811   private boolean jj_3R_162() {
34812     Token xsp;
34813     xsp = jj_scanpos;
34814     if (jj_3R_256()) {
34815     jj_scanpos = xsp;
34816     if (jj_3_64()) {
34817     jj_scanpos = xsp;
34818     if (jj_3_65()) {
34819     jj_scanpos = xsp;
34820     if (jj_3_66()) return true;
34821     }
34822     }
34823     }
34824     return false;
34825   }
34826 
34827   private boolean jj_3R_255() {
34828     Token xsp;
34829     xsp = jj_scanpos;
34830     if (jj_scan_token(100)) {
34831     jj_scanpos = xsp;
34832     if (jj_scan_token(182)) return true;
34833     }
34834     return false;
34835   }
34836 
34837   private boolean jj_3R_602() {
34838     if (jj_3R_350()) return true;
34839     return false;
34840   }
34841 
34842   private boolean jj_3_63() {
34843     Token xsp;
34844     xsp = jj_scanpos;
34845     if (jj_3R_143()) {
34846     jj_scanpos = xsp;
34847     if (jj_3R_144()) return true;
34848     }
34849     return false;
34850   }
34851 
34852   private boolean jj_3_62() {
34853     if (jj_scan_token(OID)) return true;
34854     if (jj_scan_token(STRING_LITERAL)) return true;
34855     return false;
34856   }
34857 
34858   private boolean jj_3R_254() {
34859     if (jj_scan_token(OR)) return true;
34860     if (jj_scan_token(REPLACE)) return true;
34861     return false;
34862   }
34863 
34864   private boolean jj_3R_601() {
34865     if (jj_3R_173()) return true;
34866     return false;
34867   }
34868 
34869   private boolean jj_3R_161() {
34870     if (jj_scan_token(CREATE)) return true;
34871     Token xsp;
34872     xsp = jj_scanpos;
34873     if (jj_3R_254()) jj_scanpos = xsp;
34874     xsp = jj_scanpos;
34875     if (jj_3R_255()) jj_scanpos = xsp;
34876     return false;
34877   }
34878 
34879   private boolean jj_3R_105() {
34880     Token xsp;
34881     xsp = jj_scanpos;
34882     if (jj_3R_161()) jj_scanpos = xsp;
34883     if (jj_scan_token(TYPE)) return true;
34884     if (jj_3R_154()) return true;
34885     xsp = jj_scanpos;
34886     if (jj_scan_token(123)) jj_scanpos = xsp;
34887     xsp = jj_scanpos;
34888     if (jj_3_62()) jj_scanpos = xsp;
34889     while (true) {
34890       xsp = jj_scanpos;
34891       if (jj_3_63()) { jj_scanpos = xsp; break; }
34892     }
34893     xsp = jj_scanpos;
34894     if (jj_3R_162()) jj_scanpos = xsp;
34895     xsp = jj_scanpos;
34896     if (jj_3_67()) jj_scanpos = xsp;
34897     xsp = jj_scanpos;
34898     if (jj_3R_163()) jj_scanpos = xsp;
34899     xsp = jj_scanpos;
34900     if (jj_3R_164()) jj_scanpos = xsp;
34901     while (true) {
34902       xsp = jj_scanpos;
34903       if (jj_3R_165()) { jj_scanpos = xsp; break; }
34904     }
34905     while (true) {
34906       xsp = jj_scanpos;
34907       if (jj_3R_166()) { jj_scanpos = xsp; break; }
34908     }
34909     xsp = jj_scanpos;
34910     if (jj_3R_167()) jj_scanpos = xsp;
34911     return false;
34912   }
34913 
34914   private boolean jj_3R_404() {
34915     Token xsp;
34916     xsp = jj_scanpos;
34917     if (jj_scan_token(250)) {
34918     jj_scanpos = xsp;
34919     if (jj_scan_token(297)) {
34920     jj_scanpos = xsp;
34921     if (jj_scan_token(144)) {
34922     jj_scanpos = xsp;
34923     if (jj_scan_token(93)) {
34924     jj_scanpos = xsp;
34925     if (jj_scan_token(76)) {
34926     jj_scanpos = xsp;
34927     if (jj_scan_token(241)) {
34928     jj_scanpos = xsp;
34929     if (jj_scan_token(248)) {
34930     jj_scanpos = xsp;
34931     if (jj_scan_token(111)) {
34932     jj_scanpos = xsp;
34933     if (jj_3R_441()) {
34934     jj_scanpos = xsp;
34935     if (jj_3R_442()) {
34936     jj_scanpos = xsp;
34937     if (jj_scan_token(165)) {
34938     jj_scanpos = xsp;
34939     if (jj_scan_token(318)) return true;
34940     }
34941     }
34942     }
34943     }
34944     }
34945     }
34946     }
34947     }
34948     }
34949     }
34950     }
34951     if (jj_3R_179()) return true;
34952     return false;
34953   }
34954 
34955   private boolean jj_3R_567() {
34956     if (jj_3R_191()) return true;
34957     if (jj_scan_token(BEGIN)) return true;
34958     Token xsp;
34959     while (true) {
34960       xsp = jj_scanpos;
34961       if (jj_3R_601()) { jj_scanpos = xsp; break; }
34962     }
34963     xsp = jj_scanpos;
34964     if (jj_3R_602()) jj_scanpos = xsp;
34965     if (jj_scan_token(END)) return true;
34966     xsp = jj_scanpos;
34967     if (jj_3R_603()) jj_scanpos = xsp;
34968     if (jj_scan_token(4)) return true;
34969     return false;
34970   }
34971 
34972   private boolean jj_3R_566() {
34973     if (jj_3R_123()) return true;
34974     Token xsp;
34975     xsp = jj_scanpos;
34976     if (jj_scan_token(4)) jj_scanpos = xsp;
34977     return false;
34978   }
34979 
34980   private boolean jj_3R_490() {
34981     return false;
34982   }
34983 
34984   private boolean jj_3R_530() {
34985     Token xsp;
34986     xsp = jj_scanpos;
34987     if (jj_scan_token(152)) {
34988     jj_scanpos = xsp;
34989     if (jj_scan_token(51)) return true;
34990     }
34991     xsp = jj_scanpos;
34992     if (jj_3R_566()) {
34993     jj_scanpos = xsp;
34994     if (jj_3R_567()) return true;
34995     }
34996     return false;
34997   }
34998 
34999   private boolean jj_3_60() {
35000     if (jj_3R_124()) return true;
35001     if (jj_scan_token(3)) return true;
35002     return false;
35003   }
35004 
35005   private boolean jj_3R_241() {
35006     Token xsp;
35007     xsp = jj_scanpos;
35008     if (jj_scan_token(162)) {
35009     jj_scanpos = xsp;
35010     if (jj_scan_token(204)) return true;
35011     }
35012     return false;
35013   }
35014 
35015   private boolean jj_3R_240() {
35016     Token xsp;
35017     xsp = jj_scanpos;
35018     if (jj_scan_token(183)) jj_scanpos = xsp;
35019     xsp = jj_scanpos;
35020     if (jj_scan_token(208)) {
35021     jj_scanpos = xsp;
35022     if (jj_scan_token(145)) {
35023     jj_scanpos = xsp;
35024     if (jj_scan_token(119)) return true;
35025     }
35026     }
35027     return false;
35028   }
35029 
35030   private boolean jj_3R_187() {
35031     return false;
35032   }
35033 
35034   private boolean jj_3_61() {
35035     if (jj_3R_124()) return true;
35036     if (jj_scan_token(3)) return true;
35037     if (jj_3R_124()) return true;
35038     if (jj_scan_token(3)) return true;
35039     if (jj_3R_124()) return true;
35040     return false;
35041   }
35042 
35043   private boolean jj_3R_146() {
35044     Token xsp;
35045     while (true) {
35046       xsp = jj_scanpos;
35047       if (jj_3R_240()) { jj_scanpos = xsp; break; }
35048     }
35049     xsp = jj_scanpos;
35050     if (jj_3R_241()) jj_scanpos = xsp;
35051     xsp = jj_scanpos;
35052     if (jj_scan_token(80)) {
35053     jj_scanpos = xsp;
35054     if (jj_scan_token(164)) {
35055     jj_scanpos = xsp;
35056     if (jj_scan_token(262)) return true;
35057     }
35058     }
35059     if (jj_3R_193()) return true;
35060     xsp = jj_scanpos;
35061     if (jj_scan_token(95)) jj_scanpos = xsp;
35062     xsp = jj_scanpos;
35063     if (jj_scan_token(210)) jj_scanpos = xsp;
35064     xsp = jj_scanpos;
35065     if (jj_scan_token(214)) jj_scanpos = xsp;
35066     xsp = jj_scanpos;
35067     if (jj_scan_token(236)) jj_scanpos = xsp;
35068     xsp = jj_scanpos;
35069     if (jj_3R_530()) jj_scanpos = xsp;
35070     return false;
35071   }
35072 
35073   private boolean jj_3R_189() {
35074     return false;
35075   }
35076 
35077   private boolean jj_3R_261() {
35078     if (jj_3R_124()) return true;
35079     return false;
35080   }
35081 
35082   private boolean jj_3R_458() {
35083     if (jj_3R_173()) return true;
35084     return false;
35085   }
35086 
35087   private boolean jj_3R_184() {
35088     if (jj_3R_142()) return true;
35089     if (jj_scan_token(IDENTIFIED)) return true;
35090     return false;
35091   }
35092 
35093   private boolean jj_3R_183() {
35094     if (jj_scan_token(CONNECT)) return true;
35095     if (jj_scan_token(TO)) return true;
35096     return false;
35097   }
35098 
35099   private boolean jj_3R_112() {
35100     if (jj_scan_token(CREATE)) return true;
35101     Token xsp;
35102     xsp = jj_scanpos;
35103     if (jj_scan_token(410)) jj_scanpos = xsp;
35104     xsp = jj_scanpos;
35105     if (jj_scan_token(224)) jj_scanpos = xsp;
35106     if (jj_scan_token(DATABASE)) return true;
35107     if (jj_scan_token(LINK)) return true;
35108     if (jj_3R_154()) return true;
35109     xsp = jj_scanpos;
35110     if (jj_3R_183()) {
35111     jj_scanpos = xsp;
35112     if (jj_3R_184()) return true;
35113     }
35114     return false;
35115   }
35116 
35117   private boolean jj_3R_563() {
35118     return false;
35119   }
35120 
35121   private boolean jj_3R_181() {
35122     if (jj_scan_token(OR)) return true;
35123     if (jj_scan_token(REPLACE)) return true;
35124     return false;
35125   }
35126 
35127   private boolean jj_3R_457() {
35128     if (jj_scan_token(OR)) return true;
35129     if (jj_3R_128()) return true;
35130     return false;
35131   }
35132 
35133   private boolean jj_3R_111() {
35134     if (jj_scan_token(CREATE)) return true;
35135     Token xsp;
35136     xsp = jj_scanpos;
35137     if (jj_3R_181()) jj_scanpos = xsp;
35138     if (jj_scan_token(DIRECTORY)) return true;
35139     if (jj_3R_154()) return true;
35140     if (jj_scan_token(AS)) return true;
35141     if (jj_3R_182()) return true;
35142     xsp = jj_scanpos;
35143     if (jj_scan_token(4)) {
35144     jj_scanpos = xsp;
35145     if (jj_scan_token(1)) return true;
35146     }
35147     return false;
35148   }
35149 
35150   private boolean jj_3R_180() {
35151     if (jj_scan_token(OR)) return true;
35152     if (jj_scan_token(REPLACE)) return true;
35153     return false;
35154   }
35155 
35156   private boolean jj_3R_459() {
35157     if (jj_3R_173()) return true;
35158     return false;
35159   }
35160 
35161   private boolean jj_3R_262() {
35162     if (jj_scan_token(6)) return true;
35163     return false;
35164   }
35165 
35166   private boolean jj_3R_110() {
35167     if (jj_scan_token(CREATE)) return true;
35168     Token xsp;
35169     xsp = jj_scanpos;
35170     if (jj_3R_180()) jj_scanpos = xsp;
35171     xsp = jj_scanpos;
35172     if (jj_scan_token(224)) jj_scanpos = xsp;
35173     if (jj_scan_token(SYNONYM)) return true;
35174     if (jj_3R_154()) return true;
35175     if (jj_scan_token(FOR)) return true;
35176     if (jj_3R_154()) return true;
35177     xsp = jj_scanpos;
35178     if (jj_scan_token(4)) {
35179     jj_scanpos = xsp;
35180     if (jj_scan_token(1)) return true;
35181     }
35182     return false;
35183   }
35184 
35185   private boolean jj_3R_179() {
35186     return false;
35187   }
35188 
35189   private boolean jj_3R_170() {
35190     if (jj_scan_token(OR)) return true;
35191     if (jj_scan_token(REPLACE)) return true;
35192     return false;
35193   }
35194 
35195   private boolean jj_3R_172() {
35196     if (jj_scan_token(5)) return true;
35197     if (jj_3R_261()) return true;
35198     Token xsp;
35199     while (true) {
35200       xsp = jj_scanpos;
35201       if (jj_3R_262()) { jj_scanpos = xsp; break; }
35202     }
35203     if (jj_scan_token(7)) return true;
35204     return false;
35205   }
35206 
35207   private boolean jj_3R_400() {
35208     if (jj_scan_token(WHEN)) return true;
35209     if (jj_scan_token(OTHERS)) return true;
35210     if (jj_scan_token(THEN)) return true;
35211     Token xsp;
35212     if (jj_3R_459()) return true;
35213     while (true) {
35214       xsp = jj_scanpos;
35215       if (jj_3R_459()) { jj_scanpos = xsp; break; }
35216     }
35217     return false;
35218   }
35219 
35220   private boolean jj_3_41() {
35221     if (jj_scan_token(WHEN)) return true;
35222     if (jj_3R_128()) return true;
35223     Token xsp;
35224     while (true) {
35225       xsp = jj_scanpos;
35226       if (jj_3R_457()) { jj_scanpos = xsp; break; }
35227     }
35228     if (jj_scan_token(THEN)) return true;
35229     if (jj_3R_458()) return true;
35230     while (true) {
35231       xsp = jj_scanpos;
35232       if (jj_3R_458()) { jj_scanpos = xsp; break; }
35233     }
35234     return false;
35235   }
35236 
35237   private boolean jj_3R_171() {
35238     Token xsp;
35239     xsp = jj_scanpos;
35240     if (jj_scan_token(179)) jj_scanpos = xsp;
35241     if (jj_scan_token(FORCE)) return true;
35242     return false;
35243   }
35244 
35245   private boolean jj_3R_107() {
35246     if (jj_scan_token(CREATE)) return true;
35247     Token xsp;
35248     xsp = jj_scanpos;
35249     if (jj_3R_170()) jj_scanpos = xsp;
35250     xsp = jj_scanpos;
35251     if (jj_3R_171()) jj_scanpos = xsp;
35252     if (jj_scan_token(VIEW)) return true;
35253     if (jj_3R_154()) return true;
35254     xsp = jj_scanpos;
35255     if (jj_3R_172()) jj_scanpos = xsp;
35256     if (jj_scan_token(AS)) return true;
35257     if (jj_3R_173()) return true;
35258     xsp = jj_scanpos;
35259     if (jj_scan_token(4)) {
35260     jj_scanpos = xsp;
35261     if (jj_scan_token(1)) return true;
35262     }
35263     return false;
35264   }
35265 
35266   private boolean jj_3R_169() {
35267     if (jj_3R_124()) return true;
35268     if (jj_3R_235()) return true;
35269     return false;
35270   }
35271 
35272   private boolean jj_3R_350() {
35273     if (jj_scan_token(EXCEPTION)) return true;
35274     Token xsp;
35275     while (true) {
35276       xsp = jj_scanpos;
35277       if (jj_3_41()) { jj_scanpos = xsp; break; }
35278     }
35279     xsp = jj_scanpos;
35280     if (jj_3R_400()) jj_scanpos = xsp;
35281     return false;
35282   }
35283 
35284   private boolean jj_3R_628() {
35285     if (jj_scan_token(6)) return true;
35286     if (jj_3R_124()) return true;
35287     return false;
35288   }
35289 
35290   private boolean jj_3R_627() {
35291     if (jj_scan_token(6)) return true;
35292     if (jj_3R_124()) return true;
35293     return false;
35294   }
35295 
35296   private boolean jj_3R_168() {
35297     if (jj_scan_token(GLOBAL)) return true;
35298     if (jj_scan_token(TEMPORARY)) return true;
35299     return false;
35300   }
35301 
35302   private boolean jj_3_59() {
35303     if (jj_scan_token(ON)) return true;
35304     if (jj_scan_token(COMMIT)) return true;
35305     return false;
35306   }
35307 
35308   private boolean jj_3_40() {
35309     if (jj_scan_token(5)) return true;
35310     if (jj_3R_127()) return true;
35311     if (jj_scan_token(7)) return true;
35312     return false;
35313   }
35314 
35315   private boolean jj_3R_106() {
35316     if (jj_scan_token(CREATE)) return true;
35317     Token xsp;
35318     xsp = jj_scanpos;
35319     if (jj_3R_168()) jj_scanpos = xsp;
35320     if (jj_scan_token(TABLE)) return true;
35321     if (jj_3R_154()) return true;
35322     if (jj_scan_token(5)) return true;
35323     if (jj_3R_169()) return true;
35324     return false;
35325   }
35326 
35327   private boolean jj_3R_620() {
35328     Token xsp;
35329     xsp = jj_scanpos;
35330     if (jj_scan_token(125)) {
35331     jj_scanpos = xsp;
35332     if (jj_scan_token(223)) {
35333     jj_scanpos = xsp;
35334     if (jj_scan_token(209)) {
35335     jj_scanpos = xsp;
35336     if (jj_scan_token(282)) {
35337     jj_scanpos = xsp;
35338     if (jj_scan_token(284)) return true;
35339     }
35340     }
35341     }
35342     }
35343     return false;
35344   }
35345 
35346   private boolean jj_3R_480() {
35347     if (jj_scan_token(TO)) return true;
35348     Token xsp;
35349     xsp = jj_scanpos;
35350     if (jj_scan_token(316)) {
35351     jj_scanpos = xsp;
35352     if (jj_scan_token(173)) {
35353     jj_scanpos = xsp;
35354     if (jj_scan_token(89)) {
35355     jj_scanpos = xsp;
35356     if (jj_scan_token(133)) {
35357     jj_scanpos = xsp;
35358     if (jj_scan_token(168)) {
35359     jj_scanpos = xsp;
35360     if (jj_scan_token(249)) return true;
35361     }
35362     }
35363     }
35364     }
35365     }
35366     xsp = jj_scanpos;
35367     if (jj_3_40()) jj_scanpos = xsp;
35368     return false;
35369   }
35370 
35371   private boolean jj_3R_506() {
35372     if (jj_scan_token(LOCAL)) return true;
35373     return false;
35374   }
35375 
35376   private boolean jj_3R_348() {
35377     Token xsp;
35378     xsp = jj_scanpos;
35379     if (jj_scan_token(125)) {
35380     jj_scanpos = xsp;
35381     if (jj_scan_token(223)) {
35382     jj_scanpos = xsp;
35383     if (jj_scan_token(209)) {
35384     jj_scanpos = xsp;
35385     if (jj_scan_token(282)) {
35386     jj_scanpos = xsp;
35387     if (jj_scan_token(284)) return true;
35388     }
35389     }
35390     }
35391     }
35392     return false;
35393   }
35394 
35395   private boolean jj_3R_349() {
35396     if (jj_scan_token(6)) return true;
35397     Token xsp;
35398     xsp = jj_scanpos;
35399     if (jj_3R_620()) jj_scanpos = xsp;
35400     if (jj_3R_128()) return true;
35401     return false;
35402   }
35403 
35404   private boolean jj_3R_479() {
35405     if (jj_scan_token(WITH)) return true;
35406     Token xsp;
35407     xsp = jj_scanpos;
35408     if (jj_3R_506()) jj_scanpos = xsp;
35409     if (jj_scan_token(TIME)) return true;
35410     if (jj_scan_token(ZONE)) return true;
35411     return false;
35412   }
35413 
35414   private boolean jj_3R_434() {
35415     Token xsp;
35416     xsp = jj_scanpos;
35417     if (jj_3R_479()) {
35418     jj_scanpos = xsp;
35419     if (jj_3R_480()) return true;
35420     }
35421     return false;
35422   }
35423 
35424   private boolean jj_3R_489() {
35425     if (jj_scan_token(6)) return true;
35426     if (jj_3R_127()) return true;
35427     return false;
35428   }
35429 
35430   private boolean jj_3_39() {
35431     if (jj_scan_token(5)) return true;
35432     if (jj_3R_127()) return true;
35433     if (jj_scan_token(7)) return true;
35434     return false;
35435   }
35436 
35437   private boolean jj_3R_488() {
35438     Token xsp;
35439     xsp = jj_scanpos;
35440     if (jj_scan_token(16)) {
35441     jj_scanpos = xsp;
35442     if (jj_scan_token(17)) return true;
35443     }
35444     return false;
35445   }
35446 
35447   private boolean jj_3R_238() {
35448     if (jj_scan_token(ACCESSIBLE)) return true;
35449     if (jj_scan_token(BY)) return true;
35450     if (jj_scan_token(5)) return true;
35451     Token xsp;
35452     xsp = jj_scanpos;
35453     if (jj_3R_348()) jj_scanpos = xsp;
35454     if (jj_3R_128()) return true;
35455     while (true) {
35456       xsp = jj_scanpos;
35457       if (jj_3R_349()) { jj_scanpos = xsp; break; }
35458     }
35459     if (jj_scan_token(7)) return true;
35460     return false;
35461   }
35462 
35463   private boolean jj_3R_621() {
35464     Token xsp;
35465     xsp = jj_scanpos;
35466     if (jj_scan_token(130)) {
35467     jj_scanpos = xsp;
35468     if (jj_scan_token(226)) return true;
35469     }
35470     if (jj_scan_token(5)) return true;
35471     if (jj_3R_124()) return true;
35472     while (true) {
35473       xsp = jj_scanpos;
35474       if (jj_3R_627()) { jj_scanpos = xsp; break; }
35475     }
35476     if (jj_scan_token(7)) return true;
35477     return false;
35478   }
35479 
35480   private boolean jj_3R_622() {
35481     Token xsp;
35482     xsp = jj_scanpos;
35483     if (jj_scan_token(204)) {
35484     jj_scanpos = xsp;
35485     if (jj_scan_token(71)) return true;
35486     }
35487     if (jj_scan_token(BY)) return true;
35488     if (jj_scan_token(5)) return true;
35489     if (jj_3R_124()) return true;
35490     while (true) {
35491       xsp = jj_scanpos;
35492       if (jj_3R_628()) { jj_scanpos = xsp; break; }
35493     }
35494     if (jj_scan_token(7)) return true;
35495     return false;
35496   }
35497 
35498   private boolean jj_3R_433() {
35499     Token xsp;
35500     xsp = jj_scanpos;
35501     if (jj_scan_token(316)) {
35502     jj_scanpos = xsp;
35503     if (jj_scan_token(173)) {
35504     jj_scanpos = xsp;
35505     if (jj_scan_token(89)) {
35506     jj_scanpos = xsp;
35507     if (jj_scan_token(133)) {
35508     jj_scanpos = xsp;
35509     if (jj_scan_token(168)) {
35510     jj_scanpos = xsp;
35511     if (jj_scan_token(249)) return true;
35512     }
35513     }
35514     }
35515     }
35516     }
35517     return false;
35518   }
35519 
35520   private boolean jj_3R_432() {
35521     if (jj_3R_182()) return true;
35522     return false;
35523   }
35524 
35525   private boolean jj_3R_431() {
35526     if (jj_scan_token(CHARACTER_LITERAL)) return true;
35527     return false;
35528   }
35529 
35530   private boolean jj_3R_428() {
35531     if (jj_scan_token(5)) return true;
35532     if (jj_scan_token(PARTITION)) return true;
35533     if (jj_3R_124()) return true;
35534     if (jj_scan_token(BY)) return true;
35535     Token xsp;
35536     xsp = jj_scanpos;
35537     if (jj_scan_token(49)) {
35538     jj_scanpos = xsp;
35539     if (jj_3R_621()) return true;
35540     }
35541     if (jj_scan_token(7)) return true;
35542     xsp = jj_scanpos;
35543     if (jj_3R_622()) jj_scanpos = xsp;
35544     return false;
35545   }
35546 
35547   private boolean jj_3R_119() {
35548     if (jj_3R_124()) return true;
35549     if (jj_scan_token(EXCEPTION)) return true;
35550     if (jj_scan_token(4)) return true;
35551     return false;
35552   }
35553 
35554   private boolean jj_3R_518() {
35555     if (jj_3R_182()) return true;
35556     return false;
35557   }
35558 
35559   private boolean jj_3R_421() {
35560     if (jj_scan_token(PRAGMA)) return true;
35561     if (jj_scan_token(INLINE)) return true;
35562     if (jj_scan_token(5)) return true;
35563     if (jj_3R_128()) return true;
35564     if (jj_scan_token(6)) return true;
35565     if (jj_3R_182()) return true;
35566     if (jj_scan_token(7)) return true;
35567     return false;
35568   }
35569 
35570   private boolean jj_3R_517() {
35571     if (jj_3R_124()) return true;
35572     return false;
35573   }
35574 
35575   private boolean jj_3R_468() {
35576     if (jj_3R_128()) return true;
35577     if (jj_scan_token(5)) return true;
35578     if (jj_3R_490()) return true;
35579     return false;
35580   }
35581 
35582   private boolean jj_3R_467() {
35583     if (jj_scan_token(INTERFACE)) return true;
35584     if (jj_scan_token(5)) return true;
35585     if (jj_scan_token(IDENTIFIER)) return true;
35586     if (jj_scan_token(6)) return true;
35587     if (jj_3R_124()) return true;
35588     Token xsp;
35589     xsp = jj_scanpos;
35590     if (jj_3R_489()) jj_scanpos = xsp;
35591     if (jj_scan_token(7)) return true;
35592     return false;
35593   }
35594 
35595   private boolean jj_3_34() {
35596     if (jj_scan_token(5)) return true;
35597     if (jj_3R_127()) return true;
35598     if (jj_scan_token(7)) return true;
35599     return false;
35600   }
35601 
35602   private boolean jj_3R_466() {
35603     if (jj_scan_token(EXCEPTION_INIT)) return true;
35604     if (jj_scan_token(5)) return true;
35605     if (jj_scan_token(IDENTIFIER)) return true;
35606     if (jj_scan_token(6)) return true;
35607     Token xsp;
35608     xsp = jj_scanpos;
35609     if (jj_3R_488()) jj_scanpos = xsp;
35610     if (jj_3R_127()) return true;
35611     if (jj_scan_token(7)) return true;
35612     return false;
35613   }
35614 
35615   private boolean jj_3R_487() {
35616     if (jj_scan_token(6)) return true;
35617     Token xsp;
35618     xsp = jj_scanpos;
35619     if (jj_3R_517()) {
35620     jj_scanpos = xsp;
35621     if (jj_3R_518()) return true;
35622     }
35623     return false;
35624   }
35625 
35626   private boolean jj_3R_465() {
35627     if (jj_scan_token(RESTRICT_REFERENCES)) return true;
35628     if (jj_scan_token(5)) return true;
35629     if (jj_3R_124()) return true;
35630     Token xsp;
35631     if (jj_3R_487()) return true;
35632     while (true) {
35633       xsp = jj_scanpos;
35634       if (jj_3R_487()) { jj_scanpos = xsp; break; }
35635     }
35636     if (jj_scan_token(7)) return true;
35637     return false;
35638   }
35639 
35640   private boolean jj_3R_464() {
35641     if (jj_scan_token(TIMESTAMP)) return true;
35642     if (jj_scan_token(5)) return true;
35643     if (jj_3R_182()) return true;
35644     if (jj_scan_token(7)) return true;
35645     return false;
35646   }
35647 
35648   private boolean jj_3R_392() {
35649     Token xsp;
35650     xsp = jj_scanpos;
35651     if (jj_scan_token(149)) {
35652     jj_scanpos = xsp;
35653     if (jj_scan_token(275)) {
35654     jj_scanpos = xsp;
35655     if (jj_scan_token(88)) return true;
35656     }
35657     }
35658     xsp = jj_scanpos;
35659     if (jj_3R_431()) {
35660     jj_scanpos = xsp;
35661     if (jj_3R_432()) return true;
35662     }
35663     xsp = jj_scanpos;
35664     if (jj_3R_433()) jj_scanpos = xsp;
35665     xsp = jj_scanpos;
35666     if (jj_3_39()) jj_scanpos = xsp;
35667     xsp = jj_scanpos;
35668     if (jj_3R_434()) jj_scanpos = xsp;
35669     return false;
35670   }
35671 
35672   private boolean jj_3R_422() {
35673     if (jj_scan_token(PRAGMA)) return true;
35674     Token xsp;
35675     xsp = jj_scanpos;
35676     if (jj_scan_token(38)) {
35677     jj_scanpos = xsp;
35678     if (jj_scan_token(41)) {
35679     jj_scanpos = xsp;
35680     if (jj_3R_464()) {
35681     jj_scanpos = xsp;
35682     if (jj_3R_465()) {
35683     jj_scanpos = xsp;
35684     if (jj_3R_466()) {
35685     jj_scanpos = xsp;
35686     if (jj_3R_467()) {
35687     jj_scanpos = xsp;
35688     if (jj_3R_468()) return true;
35689     }
35690     }
35691     }
35692     }
35693     }
35694     }
35695     if (jj_scan_token(4)) return true;
35696     return false;
35697   }
35698 
35699   private boolean jj_3_38() {
35700     if (jj_scan_token(TO)) return true;
35701     if (jj_scan_token(SECOND)) return true;
35702     Token xsp;
35703     xsp = jj_scanpos;
35704     if (jj_3_34()) jj_scanpos = xsp;
35705     return false;
35706   }
35707 
35708   private boolean jj_3_37() {
35709     if (jj_scan_token(TO)) return true;
35710     if (jj_scan_token(MONTH)) return true;
35711     return false;
35712   }
35713 
35714   private boolean jj_3_36() {
35715     if (jj_scan_token(WITH)) return true;
35716     if (jj_scan_token(TIME)) return true;
35717     if (jj_scan_token(ZONE)) return true;
35718     return false;
35719   }
35720 
35721   private boolean jj_3_35() {
35722     if (jj_scan_token(WITH)) return true;
35723     if (jj_scan_token(LOCAL)) return true;
35724     if (jj_scan_token(TIME)) return true;
35725     if (jj_scan_token(ZONE)) return true;
35726     return false;
35727   }
35728 
35729   private boolean jj_3R_206() {
35730     Token xsp;
35731     xsp = jj_scanpos;
35732     if (jj_3R_290()) {
35733     jj_scanpos = xsp;
35734     if (jj_3_35()) {
35735     jj_scanpos = xsp;
35736     if (jj_3_36()) {
35737     jj_scanpos = xsp;
35738     if (jj_3_37()) {
35739     jj_scanpos = xsp;
35740     if (jj_3_38()) return true;
35741     }
35742     }
35743     }
35744     }
35745     return false;
35746   }
35747 
35748   private boolean jj_3R_290() {
35749     if (jj_scan_token(CHARACTER)) return true;
35750     if (jj_scan_token(SET)) return true;
35751     if (jj_3R_294()) return true;
35752     return false;
35753   }
35754 
35755   private boolean jj_3R_440() {
35756     if (jj_scan_token(BYTE)) return true;
35757     return false;
35758   }
35759 
35760   private boolean jj_3R_439() {
35761     if (jj_scan_token(CHAR)) return true;
35762     return false;
35763   }
35764 
35765   private boolean jj_3R_121() {
35766     if (jj_3R_197()) return true;
35767     if (jj_scan_token(4)) return true;
35768     return false;
35769   }
35770 
35771   private boolean jj_3R_438() {
35772     if (jj_scan_token(6)) return true;
35773     if (jj_3R_483()) return true;
35774     return false;
35775   }
35776 
35777   private boolean jj_3R_568() {
35778     if (jj_scan_token(USING)) return true;
35779     Token xsp;
35780     xsp = jj_scanpos;
35781     if (jj_scan_token(401)) {
35782     jj_scanpos = xsp;
35783     if (jj_scan_token(402)) return true;
35784     }
35785     return false;
35786   }
35787 
35788   private boolean jj_3_33() {
35789     if (jj_scan_token(5)) return true;
35790     if (jj_3R_127()) return true;
35791     Token xsp;
35792     xsp = jj_scanpos;
35793     if (jj_3R_438()) jj_scanpos = xsp;
35794     xsp = jj_scanpos;
35795     if (jj_3R_439()) jj_scanpos = xsp;
35796     xsp = jj_scanpos;
35797     if (jj_3R_440()) jj_scanpos = xsp;
35798     if (jj_scan_token(7)) return true;
35799     return false;
35800   }
35801 
35802   private boolean jj_3_58() {
35803     if (jj_3R_142()) return true;
35804     Token xsp;
35805     xsp = jj_scanpos;
35806     if (jj_scan_token(23)) {
35807     jj_scanpos = xsp;
35808     if (jj_scan_token(51)) return true;
35809     }
35810     return false;
35811   }
35812 
35813   private boolean jj_3R_435() {
35814     Token xsp;
35815     xsp = jj_scanpos;
35816     if (jj_3_58()) jj_scanpos = xsp;
35817     if (jj_3R_233()) return true;
35818     xsp = jj_scanpos;
35819     if (jj_3R_568()) jj_scanpos = xsp;
35820     return false;
35821   }
35822 
35823   private boolean jj_3R_205() {
35824     if (jj_scan_token(SELF)) return true;
35825     if (jj_scan_token(AS)) return true;
35826     if (jj_scan_token(RESULT)) return true;
35827     return false;
35828   }
35829 
35830   private boolean jj_3R_202() {
35831     if (jj_scan_token(DOUBLE)) return true;
35832     if (jj_scan_token(PRECISION)) return true;
35833     return false;
35834   }
35835 
35836   private boolean jj_3_32() {
35837     if (jj_scan_token(INTERVAL)) return true;
35838     if (jj_scan_token(DAY)) return true;
35839     return false;
35840   }
35841 
35842   private boolean jj_3_31() {
35843     if (jj_scan_token(INTERVAL)) return true;
35844     if (jj_scan_token(YEAR)) return true;
35845     return false;
35846   }
35847 
35848   private boolean jj_3R_204() {
35849     if (jj_scan_token(REF)) return true;
35850     if (jj_scan_token(CURSOR)) return true;
35851     return false;
35852   }
35853 
35854   private boolean jj_3R_535() {
35855     if (jj_scan_token(6)) return true;
35856     if (jj_3R_435()) return true;
35857     return false;
35858   }
35859 
35860   private boolean jj_3R_393() {
35861     if (jj_3R_435()) return true;
35862     Token xsp;
35863     while (true) {
35864       xsp = jj_scanpos;
35865       if (jj_3R_535()) { jj_scanpos = xsp; break; }
35866     }
35867     return false;
35868   }
35869 
35870   private boolean jj_3_30() {
35871     if (jj_scan_token(LONG)) return true;
35872     if (jj_scan_token(RAW)) return true;
35873     return false;
35874   }
35875 
35876   private boolean jj_3R_341() {
35877     if (jj_3R_393()) return true;
35878     return false;
35879   }
35880 
35881   private boolean jj_3R_141() {
35882     if (jj_scan_token(11)) return true;
35883     return false;
35884   }
35885 
35886   private boolean jj_3R_282() {
35887     Token xsp;
35888     xsp = jj_scanpos;
35889     if (jj_scan_token(117)) {
35890     jj_scanpos = xsp;
35891     if (jj_scan_token(283)) {
35892     jj_scanpos = xsp;
35893     if (jj_scan_token(296)) {
35894     jj_scanpos = xsp;
35895     if (jj_scan_token(377)) {
35896     jj_scanpos = xsp;
35897     if (jj_scan_token(44)) {
35898     jj_scanpos = xsp;
35899     if (jj_scan_token(321)) {
35900     jj_scanpos = xsp;
35901     if (jj_scan_token(45)) {
35902     jj_scanpos = xsp;
35903     if (jj_scan_token(344)) {
35904     jj_scanpos = xsp;
35905     if (jj_scan_token(345)) {
35906     jj_scanpos = xsp;
35907     if (jj_scan_token(53)) {
35908     jj_scanpos = xsp;
35909     if (jj_scan_token(389)) {
35910     jj_scanpos = xsp;
35911     if (jj_scan_token(54)) {
35912     jj_scanpos = xsp;
35913     if (jj_scan_token(346)) {
35914     jj_scanpos = xsp;
35915     if (jj_scan_token(408)) {
35916     jj_scanpos = xsp;
35917     if (jj_scan_token(55)) {
35918     jj_scanpos = xsp;
35919     if (jj_scan_token(322)) {
35920     jj_scanpos = xsp;
35921     if (jj_scan_token(312)) {
35922     jj_scanpos = xsp;
35923     if (jj_scan_token(313)) {
35924     jj_scanpos = xsp;
35925     if (jj_scan_token(395)) {
35926     jj_scanpos = xsp;
35927     if (jj_scan_token(62)) {
35928     jj_scanpos = xsp;
35929     if (jj_scan_token(64)) {
35930     jj_scanpos = xsp;
35931     if (jj_scan_token(349)) {
35932     jj_scanpos = xsp;
35933     if (jj_scan_token(65)) {
35934     jj_scanpos = xsp;
35935     if (jj_scan_token(390)) {
35936     jj_scanpos = xsp;
35937     if (jj_scan_token(401)) {
35938     jj_scanpos = xsp;
35939     if (jj_scan_token(320)) {
35940     jj_scanpos = xsp;
35941     if (jj_scan_token(376)) {
35942     jj_scanpos = xsp;
35943     if (jj_scan_token(375)) {
35944     jj_scanpos = xsp;
35945     if (jj_scan_token(314)) {
35946     jj_scanpos = xsp;
35947     if (jj_scan_token(70)) {
35948     jj_scanpos = xsp;
35949     if (jj_scan_token(72)) {
35950     jj_scanpos = xsp;
35951     if (jj_scan_token(73)) {
35952     jj_scanpos = xsp;
35953     if (jj_scan_token(74)) {
35954     jj_scanpos = xsp;
35955     if (jj_scan_token(75)) {
35956     jj_scanpos = xsp;
35957     if (jj_scan_token(76)) {
35958     jj_scanpos = xsp;
35959     if (jj_scan_token(347)) {
35960     jj_scanpos = xsp;
35961     if (jj_scan_token(80)) {
35962     jj_scanpos = xsp;
35963     if (jj_scan_token(370)) {
35964     jj_scanpos = xsp;
35965     if (jj_scan_token(81)) {
35966     jj_scanpos = xsp;
35967     if (jj_scan_token(82)) {
35968     jj_scanpos = xsp;
35969     if (jj_scan_token(379)) {
35970     jj_scanpos = xsp;
35971     if (jj_scan_token(84)) {
35972     jj_scanpos = xsp;
35973     if (jj_scan_token(37)) {
35974     jj_scanpos = xsp;
35975     if (jj_scan_token(86)) {
35976     jj_scanpos = xsp;
35977     if (jj_scan_token(87)) {
35978     jj_scanpos = xsp;
35979     if (jj_scan_token(348)) {
35980     jj_scanpos = xsp;
35981     if (jj_scan_token(89)) {
35982     jj_scanpos = xsp;
35983     if (jj_scan_token(406)) {
35984     jj_scanpos = xsp;
35985     if (jj_scan_token(350)) {
35986     jj_scanpos = xsp;
35987     if (jj_scan_token(301)) {
35988     jj_scanpos = xsp;
35989     if (jj_scan_token(380)) {
35990     jj_scanpos = xsp;
35991     if (jj_scan_token(36)) {
35992     jj_scanpos = xsp;
35993     if (jj_scan_token(411)) {
35994     jj_scanpos = xsp;
35995     if (jj_scan_token(96)) {
35996     jj_scanpos = xsp;
35997     if (jj_scan_token(351)) {
35998     jj_scanpos = xsp;
35999     if (jj_scan_token(381)) {
36000     jj_scanpos = xsp;
36001     if (jj_scan_token(300)) {
36002     jj_scanpos = xsp;
36003     if (jj_scan_token(352)) {
36004     jj_scanpos = xsp;
36005     if (jj_scan_token(101)) {
36006     jj_scanpos = xsp;
36007     if (jj_scan_token(396)) {
36008     jj_scanpos = xsp;
36009     if (jj_scan_token(104)) {
36010     jj_scanpos = xsp;
36011     if (jj_scan_token(106)) {
36012     jj_scanpos = xsp;
36013     if (jj_scan_token(107)) {
36014     jj_scanpos = xsp;
36015     if (jj_scan_token(109)) {
36016     jj_scanpos = xsp;
36017     if (jj_scan_token(113)) {
36018     jj_scanpos = xsp;
36019     if (jj_scan_token(115)) {
36020     jj_scanpos = xsp;
36021     if (jj_scan_token(114)) {
36022     jj_scanpos = xsp;
36023     if (jj_scan_token(116)) {
36024     jj_scanpos = xsp;
36025     if (jj_scan_token(119)) {
36026     jj_scanpos = xsp;
36027     if (jj_scan_token(353)) {
36028     jj_scanpos = xsp;
36029     if (jj_scan_token(123)) {
36030     jj_scanpos = xsp;
36031     if (jj_scan_token(125)) {
36032     jj_scanpos = xsp;
36033     if (jj_scan_token(126)) {
36034     jj_scanpos = xsp;
36035     if (jj_scan_token(130)) {
36036     jj_scanpos = xsp;
36037     if (jj_scan_token(132)) {
36038     jj_scanpos = xsp;
36039     if (jj_scan_token(382)) {
36040     jj_scanpos = xsp;
36041     if (jj_scan_token(133)) {
36042     jj_scanpos = xsp;
36043     if (jj_scan_token(136)) {
36044     jj_scanpos = xsp;
36045     if (jj_scan_token(142)) {
36046     jj_scanpos = xsp;
36047     if (jj_scan_token(143)) {
36048     jj_scanpos = xsp;
36049     if (jj_scan_token(140)) {
36050     jj_scanpos = xsp;
36051     if (jj_scan_token(145)) {
36052     jj_scanpos = xsp;
36053     if (jj_scan_token(149)) {
36054     jj_scanpos = xsp;
36055     if (jj_scan_token(151)) {
36056     jj_scanpos = xsp;
36057     if (jj_scan_token(153)) {
36058     jj_scanpos = xsp;
36059     if (jj_scan_token(154)) {
36060     jj_scanpos = xsp;
36061     if (jj_scan_token(42)) {
36062     jj_scanpos = xsp;
36063     if (jj_scan_token(399)) {
36064     jj_scanpos = xsp;
36065     if (jj_scan_token(393)) {
36066     jj_scanpos = xsp;
36067     if (jj_scan_token(372)) {
36068     jj_scanpos = xsp;
36069     if (jj_scan_token(155)) {
36070     jj_scanpos = xsp;
36071     if (jj_scan_token(367)) {
36072     jj_scanpos = xsp;
36073     if (jj_scan_token(157)) {
36074     jj_scanpos = xsp;
36075     if (jj_scan_token(409)) {
36076     jj_scanpos = xsp;
36077     if (jj_scan_token(317)) {
36078     jj_scanpos = xsp;
36079     if (jj_scan_token(354)) {
36080     jj_scanpos = xsp;
36081     if (jj_scan_token(355)) {
36082     jj_scanpos = xsp;
36083     if (jj_scan_token(162)) {
36084     jj_scanpos = xsp;
36085     if (jj_scan_token(163)) {
36086     jj_scanpos = xsp;
36087     if (jj_scan_token(374)) {
36088     jj_scanpos = xsp;
36089     if (jj_scan_token(164)) {
36090     jj_scanpos = xsp;
36091     if (jj_scan_token(165)) {
36092     jj_scanpos = xsp;
36093     if (jj_scan_token(166)) {
36094     jj_scanpos = xsp;
36095     if (jj_scan_token(168)) {
36096     jj_scanpos = xsp;
36097     if (jj_scan_token(169)) {
36098     jj_scanpos = xsp;
36099     if (jj_scan_token(170)) {
36100     jj_scanpos = xsp;
36101     if (jj_scan_token(173)) {
36102     jj_scanpos = xsp;
36103     if (jj_scan_token(397)) {
36104     jj_scanpos = xsp;
36105     if (jj_scan_token(368)) {
36106     jj_scanpos = xsp;
36107     if (jj_scan_token(174)) {
36108     jj_scanpos = xsp;
36109     if (jj_scan_token(306)) {
36110     jj_scanpos = xsp;
36111     if (jj_scan_token(402)) {
36112     jj_scanpos = xsp;
36113     if (jj_scan_token(315)) {
36114     jj_scanpos = xsp;
36115     if (jj_scan_token(356)) {
36116     jj_scanpos = xsp;
36117     if (jj_scan_token(176)) {
36118     jj_scanpos = xsp;
36119     if (jj_scan_token(179)) {
36120     jj_scanpos = xsp;
36121     if (jj_scan_token(357)) {
36122     jj_scanpos = xsp;
36123     if (jj_scan_token(304)) {
36124     jj_scanpos = xsp;
36125     if (jj_scan_token(307)) {
36126     jj_scanpos = xsp;
36127     if (jj_scan_token(193)) {
36128     jj_scanpos = xsp;
36129     if (jj_scan_token(196)) {
36130     jj_scanpos = xsp;
36131     if (jj_scan_token(326)) {
36132     jj_scanpos = xsp;
36133     if (jj_scan_token(199)) {
36134     jj_scanpos = xsp;
36135     if (jj_scan_token(200)) {
36136     jj_scanpos = xsp;
36137     if (jj_scan_token(205)) {
36138     jj_scanpos = xsp;
36139     if (jj_scan_token(206)) {
36140     jj_scanpos = xsp;
36141     if (jj_scan_token(208)) {
36142     jj_scanpos = xsp;
36143     if (jj_scan_token(209)) {
36144     jj_scanpos = xsp;
36145     if (jj_scan_token(371)) {
36146     jj_scanpos = xsp;
36147     if (jj_scan_token(327)) {
36148     jj_scanpos = xsp;
36149     if (jj_scan_token(211)) {
36150     jj_scanpos = xsp;
36151     if (jj_scan_token(302)) {
36152     jj_scanpos = xsp;
36153     if (jj_scan_token(219)) {
36154     jj_scanpos = xsp;
36155     if (jj_scan_token(383)) {
36156     jj_scanpos = xsp;
36157     if (jj_scan_token(223)) {
36158     jj_scanpos = xsp;
36159     if (jj_scan_token(384)) {
36160     jj_scanpos = xsp;
36161     if (jj_scan_token(226)) {
36162     jj_scanpos = xsp;
36163     if (jj_scan_token(228)) {
36164     jj_scanpos = xsp;
36165     if (jj_scan_token(229)) {
36166     jj_scanpos = xsp;
36167     if (jj_scan_token(230)) {
36168     jj_scanpos = xsp;
36169     if (jj_scan_token(232)) {
36170     jj_scanpos = xsp;
36171     if (jj_scan_token(385)) {
36172     jj_scanpos = xsp;
36173     if (jj_scan_token(235)) {
36174     jj_scanpos = xsp;
36175     if (jj_scan_token(237)) {
36176     jj_scanpos = xsp;
36177     if (jj_scan_token(238)) {
36178     jj_scanpos = xsp;
36179     if (jj_scan_token(239)) {
36180     jj_scanpos = xsp;
36181     if (jj_scan_token(394)) {
36182     jj_scanpos = xsp;
36183     if (jj_scan_token(241)) {
36184     jj_scanpos = xsp;
36185     if (jj_scan_token(242)) {
36186     jj_scanpos = xsp;
36187     if (jj_scan_token(244)) {
36188     jj_scanpos = xsp;
36189     if (jj_scan_token(245)) {
36190     jj_scanpos = xsp;
36191     if (jj_scan_token(243)) {
36192     jj_scanpos = xsp;
36193     if (jj_scan_token(247)) {
36194     jj_scanpos = xsp;
36195     if (jj_scan_token(248)) {
36196     jj_scanpos = xsp;
36197     if (jj_scan_token(358)) {
36198     jj_scanpos = xsp;
36199     if (jj_scan_token(249)) {
36200     jj_scanpos = xsp;
36201     if (jj_scan_token(251)) {
36202     jj_scanpos = xsp;
36203     if (jj_scan_token(359)) {
36204     jj_scanpos = xsp;
36205     if (jj_scan_token(407)) {
36206     jj_scanpos = xsp;
36207     if (jj_scan_token(253)) {
36208     jj_scanpos = xsp;
36209     if (jj_scan_token(410)) {
36210     jj_scanpos = xsp;
36211     if (jj_scan_token(360)) {
36212     jj_scanpos = xsp;
36213     if (jj_scan_token(257)) {
36214     jj_scanpos = xsp;
36215     if (jj_scan_token(361)) {
36216     jj_scanpos = xsp;
36217     if (jj_scan_token(362)) {
36218     jj_scanpos = xsp;
36219     if (jj_scan_token(262)) {
36220     jj_scanpos = xsp;
36221     if (jj_scan_token(363)) {
36222     jj_scanpos = xsp;
36223     if (jj_scan_token(369)) {
36224     jj_scanpos = xsp;
36225     if (jj_scan_token(398)) {
36226     jj_scanpos = xsp;
36227     if (jj_scan_token(265)) {
36228     jj_scanpos = xsp;
36229     if (jj_scan_token(264)) {
36230     jj_scanpos = xsp;
36231     if (jj_scan_token(266)) {
36232     jj_scanpos = xsp;
36233     if (jj_scan_token(364)) {
36234     jj_scanpos = xsp;
36235     if (jj_scan_token(373)) {
36236     jj_scanpos = xsp;
36237     if (jj_scan_token(272)) {
36238     jj_scanpos = xsp;
36239     if (jj_scan_token(274)) {
36240     jj_scanpos = xsp;
36241     if (jj_scan_token(275)) {
36242     jj_scanpos = xsp;
36243     if (jj_scan_token(277)) {
36244     jj_scanpos = xsp;
36245     if (jj_scan_token(279)) {
36246     jj_scanpos = xsp;
36247     if (jj_scan_token(278)) {
36248     jj_scanpos = xsp;
36249     if (jj_scan_token(276)) {
36250     jj_scanpos = xsp;
36251     if (jj_scan_token(400)) {
36252     jj_scanpos = xsp;
36253     if (jj_scan_token(281)) {
36254     jj_scanpos = xsp;
36255     if (jj_scan_token(391)) {
36256     jj_scanpos = xsp;
36257     if (jj_scan_token(392)) {
36258     jj_scanpos = xsp;
36259     if (jj_scan_token(365)) {
36260     jj_scanpos = xsp;
36261     if (jj_scan_token(386)) {
36262     jj_scanpos = xsp;
36263     if (jj_scan_token(286)) {
36264     jj_scanpos = xsp;
36265     if (jj_scan_token(309)) {
36266     jj_scanpos = xsp;
36267     if (jj_scan_token(412)) {
36268     jj_scanpos = xsp;
36269     if (jj_scan_token(288)) {
36270     jj_scanpos = xsp;
36271     if (jj_scan_token(310)) {
36272     jj_scanpos = xsp;
36273     if (jj_scan_token(387)) {
36274     jj_scanpos = xsp;
36275     if (jj_scan_token(311)) {
36276     jj_scanpos = xsp;
36277     if (jj_scan_token(388)) {
36278     jj_scanpos = xsp;
36279     if (jj_scan_token(316)) {
36280     jj_scanpos = xsp;
36281     if (jj_scan_token(293)) {
36282     jj_scanpos = xsp;
36283     if (jj_scan_token(319)) {
36284     jj_scanpos = xsp;
36285     if (jj_scan_token(294)) {
36286     jj_scanpos = xsp;
36287     if (jj_scan_token(366)) {
36288     jj_scanpos = xsp;
36289     if (jj_scan_token(270)) {
36290     jj_scanpos = xsp;
36291     if (jj_scan_token(100)) {
36292     jj_scanpos = xsp;
36293     if (jj_scan_token(182)) {
36294     jj_scanpos = xsp;
36295     if (jj_scan_token(378)) {
36296     jj_scanpos = xsp;
36297     if (jj_scan_token(186)) {
36298     jj_scanpos = xsp;
36299     if (jj_scan_token(233)) {
36300     jj_scanpos = xsp;
36301     if (jj_scan_token(231)) {
36302     jj_scanpos = xsp;
36303     if (jj_scan_token(43)) return true;
36304     }
36305     }
36306     }
36307     }
36308     }
36309     }
36310     }
36311     }
36312     }
36313     }
36314     }
36315     }
36316     }
36317     }
36318     }
36319     }
36320     }
36321     }
36322     }
36323     }
36324     }
36325     }
36326     }
36327     }
36328     }
36329     }
36330     }
36331     }
36332     }
36333     }
36334     }
36335     }
36336     }
36337     }
36338     }
36339     }
36340     }
36341     }
36342     }
36343     }
36344     }
36345     }
36346     }
36347     }
36348     }
36349     }
36350     }
36351     }
36352     }
36353     }
36354     }
36355     }
36356     }
36357     }
36358     }
36359     }
36360     }
36361     }
36362     }
36363     }
36364     }
36365     }
36366     }
36367     }
36368     }
36369     }
36370     }
36371     }
36372     }
36373     }
36374     }
36375     }
36376     }
36377     }
36378     }
36379     }
36380     }
36381     }
36382     }
36383     }
36384     }
36385     }
36386     }
36387     }
36388     }
36389     }
36390     }
36391     }
36392     }
36393     }
36394     }
36395     }
36396     }
36397     }
36398     }
36399     }
36400     }
36401     }
36402     }
36403     }
36404     }
36405     }
36406     }
36407     }
36408     }
36409     }
36410     }
36411     }
36412     }
36413     }
36414     }
36415     }
36416     }
36417     }
36418     }
36419     }
36420     }
36421     }
36422     }
36423     }
36424     }
36425     }
36426     }
36427     }
36428     }
36429     }
36430     }
36431     }
36432     }
36433     }
36434     }
36435     }
36436     }
36437     }
36438     }
36439     }
36440     }
36441     }
36442     }
36443     }
36444     }
36445     }
36446     }
36447     }
36448     }
36449     }
36450     }
36451     }
36452     }
36453     }
36454     }
36455     }
36456     }
36457     }
36458     }
36459     }
36460     }
36461     }
36462     }
36463     }
36464     }
36465     }
36466     }
36467     }
36468     }
36469     }
36470     }
36471     }
36472     }
36473     }
36474     }
36475     }
36476     }
36477     }
36478     }
36479     }
36480     }
36481     }
36482     }
36483     }
36484     }
36485     }
36486     }
36487     }
36488     }
36489     }
36490     }
36491     }
36492     }
36493     }
36494     }
36495     }
36496     }
36497     }
36498     }
36499     }
36500     }
36501     }
36502     }
36503     }
36504     }
36505     }
36506     }
36507     }
36508     }
36509     }
36510     }
36511     return false;
36512   }
36513 
36514   private boolean jj_3R_298() {
36515     if (jj_scan_token(5)) return true;
36516     Token xsp;
36517     xsp = jj_scanpos;
36518     if (jj_3R_341()) jj_scanpos = xsp;
36519     if (jj_scan_token(7)) return true;
36520     return false;
36521   }
36522 
36523   private boolean jj_3R_352() {
36524     if (jj_scan_token(3)) return true;
36525     if (jj_3R_120()) return true;
36526     return false;
36527   }
36528 
36529   private boolean jj_3R_203() {
36530     Token xsp;
36531     xsp = jj_scanpos;
36532     if (jj_scan_token(67)) {
36533     jj_scanpos = xsp;
36534     if (jj_scan_token(320)) {
36535     jj_scanpos = xsp;
36536     if (jj_3_30()) {
36537     jj_scanpos = xsp;
36538     if (jj_scan_token(160)) {
36539     jj_scanpos = xsp;
36540     if (jj_scan_token(306)) {
36541     jj_scanpos = xsp;
36542     if (jj_scan_token(307)) {
36543     jj_scanpos = xsp;
36544     if (jj_scan_token(227)) {
36545     jj_scanpos = xsp;
36546     if (jj_scan_token(244)) {
36547     jj_scanpos = xsp;
36548     if (jj_scan_token(308)) {
36549     jj_scanpos = xsp;
36550     if (jj_scan_token(309)) {
36551     jj_scanpos = xsp;
36552     if (jj_scan_token(298)) {
36553     jj_scanpos = xsp;
36554     if (jj_scan_token(299)) {
36555     jj_scanpos = xsp;
36556     if (jj_scan_token(314)) {
36557     jj_scanpos = xsp;
36558     if (jj_scan_token(315)) return true;
36559     }
36560     }
36561     }
36562     }
36563     }
36564     }
36565     }
36566     }
36567     }
36568     }
36569     }
36570     }
36571     }
36572     return false;
36573   }
36574 
36575   private boolean jj_3R_128() {
36576     if (jj_3R_142()) return true;
36577     Token xsp;
36578     while (true) {
36579       xsp = jj_scanpos;
36580       if (jj_3R_352()) { jj_scanpos = xsp; break; }
36581     }
36582     return false;
36583   }
36584 
36585   private boolean jj_3R_126() {
36586     Token xsp;
36587     xsp = jj_scanpos;
36588     if (jj_scan_token(188)) {
36589     jj_scanpos = xsp;
36590     if (jj_scan_token(189)) {
36591     jj_scanpos = xsp;
36592     if (jj_scan_token(68)) {
36593     jj_scanpos = xsp;
36594     if (jj_scan_token(190)) {
36595     jj_scanpos = xsp;
36596     if (jj_scan_token(191)) {
36597     jj_scanpos = xsp;
36598     if (jj_scan_token(192)) {
36599     jj_scanpos = xsp;
36600     if (jj_scan_token(59)) {
36601     jj_scanpos = xsp;
36602     if (jj_scan_token(301)) {
36603     jj_scanpos = xsp;
36604     if (jj_scan_token(91)) {
36605     jj_scanpos = xsp;
36606     if (jj_3R_202()) {
36607     jj_scanpos = xsp;
36608     if (jj_scan_token(120)) {
36609     jj_scanpos = xsp;
36610     if (jj_scan_token(303)) {
36611     jj_scanpos = xsp;
36612     if (jj_scan_token(146)) {
36613     jj_scanpos = xsp;
36614     if (jj_scan_token(174)) {
36615     jj_scanpos = xsp;
36616     if (jj_scan_token(175)) {
36617     jj_scanpos = xsp;
36618     if (jj_scan_token(187)) {
36619     jj_scanpos = xsp;
36620     if (jj_scan_token(304)) {
36621     jj_scanpos = xsp;
36622     if (jj_scan_token(215)) {
36623     jj_scanpos = xsp;
36624     if (jj_scan_token(216)) {
36625     jj_scanpos = xsp;
36626     if (jj_scan_token(217)) {
36627     jj_scanpos = xsp;
36628     if (jj_scan_token(228)) {
36629     jj_scanpos = xsp;
36630     if (jj_scan_token(305)) {
36631     jj_scanpos = xsp;
36632     if (jj_scan_token(256)) {
36633     jj_scanpos = xsp;
36634     if (jj_3R_203()) {
36635     jj_scanpos = xsp;
36636     if (jj_scan_token(61)) {
36637     jj_scanpos = xsp;
36638     if (jj_scan_token(312)) {
36639     jj_scanpos = xsp;
36640     if (jj_scan_token(313)) {
36641     jj_scanpos = xsp;
36642     if (jj_scan_token(270)) {
36643     jj_scanpos = xsp;
36644     if (jj_3R_204()) {
36645     jj_scanpos = xsp;
36646     if (jj_scan_token(88)) {
36647     jj_scanpos = xsp;
36648     if (jj_3_31()) {
36649     jj_scanpos = xsp;
36650     if (jj_3_32()) {
36651     jj_scanpos = xsp;
36652     if (jj_scan_token(274)) {
36653     jj_scanpos = xsp;
36654     if (jj_scan_token(275)) {
36655     jj_scanpos = xsp;
36656     if (jj_3R_205()) return true;
36657     }
36658     }
36659     }
36660     }
36661     }
36662     }
36663     }
36664     }
36665     }
36666     }
36667     }
36668     }
36669     }
36670     }
36671     }
36672     }
36673     }
36674     }
36675     }
36676     }
36677     }
36678     }
36679     }
36680     }
36681     }
36682     }
36683     }
36684     }
36685     }
36686     }
36687     }
36688     }
36689     }
36690     }
36691     xsp = jj_scanpos;
36692     if (jj_3_33()) jj_scanpos = xsp;
36693     xsp = jj_scanpos;
36694     if (jj_3R_206()) jj_scanpos = xsp;
36695     return false;
36696   }
36697 
36698   private boolean jj_3R_239() {
36699     if (jj_scan_token(VARYING)) return true;
36700     if (jj_scan_token(ARRAY)) return true;
36701     return false;
36702   }
36703 
36704   private boolean jj_3R_140() {
36705     if (jj_scan_token(3)) return true;
36706     return false;
36707   }
36708 
36709   private boolean jj_3_57() {
36710     Token xsp;
36711     xsp = jj_scanpos;
36712     if (jj_3R_140()) {
36713     jj_scanpos = xsp;
36714     if (jj_3R_141()) return true;
36715     }
36716     if (jj_3R_120()) return true;
36717     return false;
36718   }
36719 
36720   private boolean jj_3R_294() {
36721     if (jj_3R_142()) return true;
36722     Token xsp;
36723     while (true) {
36724       xsp = jj_scanpos;
36725       if (jj_3_57()) { jj_scanpos = xsp; break; }
36726     }
36727     return false;
36728   }
36729 
36730   private boolean jj_3_29() {
36731     if (jj_scan_token(5)) return true;
36732     if (jj_3R_127()) return true;
36733     return false;
36734   }
36735 
36736   private boolean jj_3R_190() {
36737     if (jj_scan_token(21)) return true;
36738     if (jj_3R_142()) return true;
36739     if (jj_scan_token(22)) return true;
36740     return false;
36741   }
36742 
36743   private boolean jj_3R_145() {
36744     Token xsp;
36745     xsp = jj_scanpos;
36746     if (jj_scan_token(271)) {
36747     jj_scanpos = xsp;
36748     if (jj_scan_token(310)) {
36749     jj_scanpos = xsp;
36750     if (jj_3R_239()) return true;
36751     }
36752     }
36753     xsp = jj_scanpos;
36754     if (jj_3_29()) jj_scanpos = xsp;
36755     return false;
36756   }
36757 
36758   private boolean jj_3R_399() {
36759     if (jj_scan_token(CC_ELSE)) return true;
36760     if (jj_3R_235()) return true;
36761     return false;
36762   }
36763 
36764   private boolean jj_3R_127() {
36765     if (jj_scan_token(UNSIGNED_NUMERIC_LITERAL)) return true;
36766     return false;
36767   }
36768 
36769   private boolean jj_3R_398() {
36770     if (jj_scan_token(CC_ELSIF)) return true;
36771     if (jj_3R_343()) return true;
36772     if (jj_scan_token(CC_THEN)) return true;
36773     if (jj_3R_235()) return true;
36774     return false;
36775   }
36776 
36777   private boolean jj_3R_345() {
36778     if (jj_scan_token(CC_IF)) return true;
36779     if (jj_3R_343()) return true;
36780     if (jj_scan_token(CC_THEN)) return true;
36781     if (jj_3R_235()) return true;
36782     Token xsp;
36783     while (true) {
36784       xsp = jj_scanpos;
36785       if (jj_3R_398()) { jj_scanpos = xsp; break; }
36786     }
36787     while (true) {
36788       xsp = jj_scanpos;
36789       if (jj_3R_399()) { jj_scanpos = xsp; break; }
36790     }
36791     if (jj_scan_token(CC_END)) return true;
36792     return false;
36793   }
36794 
36795   private boolean jj_3R_347() {
36796     if (jj_scan_token(11)) return true;
36797     Token xsp;
36798     xsp = jj_scanpos;
36799     if (jj_scan_token(284)) {
36800     jj_scanpos = xsp;
36801     if (jj_scan_token(246)) return true;
36802     }
36803     return false;
36804   }
36805 
36806   private boolean jj_3R_346() {
36807     if (jj_scan_token(2)) return true;
36808     if (jj_3R_128()) return true;
36809     return false;
36810   }
36811 
36812   private boolean jj_3_27() {
36813     if (jj_scan_token(REF)) return true;
36814     return false;
36815   }
36816 
36817   private boolean jj_3R_226() {
36818     if (jj_scan_token(A)) return true;
36819     if (jj_scan_token(SET)) return true;
36820     return false;
36821   }
36822 
36823   private boolean jj_3R_304() {
36824     Token xsp;
36825     xsp = jj_scanpos;
36826     if (jj_3_27()) jj_scanpos = xsp;
36827     if (jj_3R_128()) return true;
36828     xsp = jj_scanpos;
36829     if (jj_3R_346()) jj_scanpos = xsp;
36830     xsp = jj_scanpos;
36831     if (jj_3R_347()) jj_scanpos = xsp;
36832     return false;
36833   }
36834 
36835   private boolean jj_3R_136() {
36836     Token xsp;
36837     xsp = jj_scanpos;
36838     if (jj_3R_226()) {
36839     jj_scanpos = xsp;
36840     if (jj_scan_token(396)) return true;
36841     }
36842     return false;
36843   }
36844 
36845   private boolean jj_3_28() {
36846     if (jj_3R_126()) return true;
36847     return false;
36848   }
36849 
36850   private boolean jj_3R_303() {
36851     if (jj_3R_345()) return true;
36852     return false;
36853   }
36854 
36855   private boolean jj_3R_235() {
36856     Token xsp;
36857     xsp = jj_scanpos;
36858     if (jj_3R_303()) {
36859     jj_scanpos = xsp;
36860     if (jj_3_28()) {
36861     jj_scanpos = xsp;
36862     if (jj_3R_304()) return true;
36863     }
36864     }
36865     return false;
36866   }
36867 
36868   private boolean jj_3R_391() {
36869     if (jj_scan_token(NULL)) return true;
36870     return false;
36871   }
36872 
36873   private boolean jj_3R_334() {
36874     if (jj_scan_token(_DEFAULT)) return true;
36875     return false;
36876   }
36877 
36878   private boolean jj_3R_390() {
36879     Token xsp;
36880     xsp = jj_scanpos;
36881     if (jj_scan_token(283)) {
36882     jj_scanpos = xsp;
36883     if (jj_scan_token(117)) return true;
36884     }
36885     return false;
36886   }
36887 
36888   private boolean jj_3R_335() {
36889     if (jj_3R_233()) return true;
36890     return false;
36891   }
36892 
36893   private boolean jj_3R_283() {
36894     if (jj_3R_124()) return true;
36895     return false;
36896   }
36897 
36898   private boolean jj_3R_333() {
36899     if (jj_scan_token(9)) return true;
36900     if (jj_scan_token(10)) return true;
36901     return false;
36902   }
36903 
36904   private boolean jj_3R_285() {
36905     Token xsp;
36906     xsp = jj_scanpos;
36907     if (jj_3R_333()) {
36908     jj_scanpos = xsp;
36909     if (jj_3R_334()) return true;
36910     }
36911     if (jj_3R_335()) return true;
36912     return false;
36913   }
36914 
36915   private boolean jj_3R_332() {
36916     if (jj_scan_token(NOT)) return true;
36917     return false;
36918   }
36919 
36920   private boolean jj_3R_284() {
36921     Token xsp;
36922     xsp = jj_scanpos;
36923     if (jj_3R_332()) jj_scanpos = xsp;
36924     if (jj_scan_token(NULL)) return true;
36925     return false;
36926   }
36927 
36928   private boolean jj_3_26() {
36929     if (jj_scan_token(CONSTANT)) return true;
36930     return false;
36931   }
36932 
36933   private boolean jj_3R_197() {
36934     if (jj_3R_283()) return true;
36935     Token xsp;
36936     xsp = jj_scanpos;
36937     if (jj_3_26()) jj_scanpos = xsp;
36938     if (jj_3R_235()) return true;
36939     xsp = jj_scanpos;
36940     if (jj_3R_284()) jj_scanpos = xsp;
36941     xsp = jj_scanpos;
36942     if (jj_3R_285()) jj_scanpos = xsp;
36943     return false;
36944   }
36945 
36946   private boolean jj_3R_514() {
36947     if (jj_scan_token(6)) return true;
36948     if (jj_3R_474()) return true;
36949     return false;
36950   }
36951 
36952   private boolean jj_3R_427() {
36953     if (jj_3R_474()) return true;
36954     Token xsp;
36955     while (true) {
36956       xsp = jj_scanpos;
36957       if (jj_3R_514()) { jj_scanpos = xsp; break; }
36958     }
36959     return false;
36960   }
36961 
36962   private boolean jj_3R_385() {
36963     if (jj_scan_token(5)) return true;
36964     Token xsp;
36965     xsp = jj_scanpos;
36966     if (jj_3R_427()) jj_scanpos = xsp;
36967     if (jj_scan_token(7)) return true;
36968     return false;
36969   }
36970 
36971   private boolean jj_3R_182() {
36972     if (jj_scan_token(STRING_LITERAL)) return true;
36973     return false;
36974   }
36975 
36976   private boolean jj_3_23() {
36977     if (jj_scan_token(NOCOPY)) return true;
36978     return false;
36979   }
36980 
36981   private boolean jj_3R_325() {
36982     if (jj_3R_385()) return true;
36983     return false;
36984   }
36985 
36986   private boolean jj_3R_324() {
36987     if (jj_scan_token(RETURN)) return true;
36988     if (jj_3R_235()) return true;
36989     return false;
36990   }
36991 
36992   private boolean jj_3R_278() {
36993     if (jj_scan_token(PROCEDURE)) return true;
36994     if (jj_3R_154()) return true;
36995     Token xsp;
36996     xsp = jj_scanpos;
36997     if (jj_3R_325()) jj_scanpos = xsp;
36998     return false;
36999   }
37000 
37001   private boolean jj_3R_196() {
37002     if (jj_3R_282()) return true;
37003     return false;
37004   }
37005 
37006   private boolean jj_3R_463() {
37007     if (jj_3R_124()) return true;
37008     return false;
37009   }
37010 
37011   private boolean jj_3R_125() {
37012     if (jj_scan_token(IN)) return true;
37013     if (jj_scan_token(OUT)) return true;
37014     return false;
37015   }
37016 
37017   private boolean jj_3R_340() {
37018     if (jj_3R_392()) return true;
37019     return false;
37020   }
37021 
37022   private boolean jj_3R_339() {
37023     if (jj_3R_391()) return true;
37024     return false;
37025   }
37026 
37027   private boolean jj_3R_338() {
37028     if (jj_3R_390()) return true;
37029     return false;
37030   }
37031 
37032   private boolean jj_3R_337() {
37033     if (jj_3R_182()) return true;
37034     return false;
37035   }
37036 
37037   private boolean jj_3R_323() {
37038     if (jj_3R_385()) return true;
37039     return false;
37040   }
37041 
37042   private boolean jj_3R_120() {
37043     Token xsp;
37044     xsp = jj_scanpos;
37045     if (jj_scan_token(420)) {
37046     jj_scanpos = xsp;
37047     if (jj_scan_token(428)) {
37048     jj_scanpos = xsp;
37049     if (jj_3R_196()) {
37050     jj_scanpos = xsp;
37051     if (jj_scan_token(35)) {
37052     jj_scanpos = xsp;
37053     if (jj_scan_token(38)) {
37054     jj_scanpos = xsp;
37055     if (jj_scan_token(39)) {
37056     jj_scanpos = xsp;
37057     if (jj_scan_token(40)) {
37058     jj_scanpos = xsp;
37059     if (jj_scan_token(41)) {
37060     jj_scanpos = xsp;
37061     if (jj_scan_token(50)) {
37062     jj_scanpos = xsp;
37063     if (jj_scan_token(56)) {
37064     jj_scanpos = xsp;
37065     if (jj_scan_token(59)) {
37066     jj_scanpos = xsp;
37067     if (jj_scan_token(60)) {
37068     jj_scanpos = xsp;
37069     if (jj_scan_token(61)) {
37070     jj_scanpos = xsp;
37071     if (jj_scan_token(67)) {
37072     jj_scanpos = xsp;
37073     if (jj_scan_token(68)) {
37074     jj_scanpos = xsp;
37075     if (jj_scan_token(79)) {
37076     jj_scanpos = xsp;
37077     if (jj_scan_token(85)) {
37078     jj_scanpos = xsp;
37079     if (jj_scan_token(88)) {
37080     jj_scanpos = xsp;
37081     if (jj_scan_token(91)) {
37082     jj_scanpos = xsp;
37083     if (jj_scan_token(93)) {
37084     jj_scanpos = xsp;
37085     if (jj_scan_token(98)) {
37086     jj_scanpos = xsp;
37087     if (jj_scan_token(103)) {
37088     jj_scanpos = xsp;
37089     if (jj_scan_token(111)) {
37090     jj_scanpos = xsp;
37091     if (jj_scan_token(112)) {
37092     jj_scanpos = xsp;
37093     if (jj_scan_token(120)) {
37094     jj_scanpos = xsp;
37095     if (jj_scan_token(122)) {
37096     jj_scanpos = xsp;
37097     if (jj_scan_token(146)) {
37098     jj_scanpos = xsp;
37099     if (jj_scan_token(147)) {
37100     jj_scanpos = xsp;
37101     if (jj_scan_token(160)) {
37102     jj_scanpos = xsp;
37103     if (jj_scan_token(161)) {
37104     jj_scanpos = xsp;
37105     if (jj_scan_token(171)) {
37106     jj_scanpos = xsp;
37107     if (jj_scan_token(175)) {
37108     jj_scanpos = xsp;
37109     if (jj_scan_token(178)) {
37110     jj_scanpos = xsp;
37111     if (jj_scan_token(181)) {
37112     jj_scanpos = xsp;
37113     if (jj_scan_token(187)) {
37114     jj_scanpos = xsp;
37115     if (jj_scan_token(188)) {
37116     jj_scanpos = xsp;
37117     if (jj_scan_token(189)) {
37118     jj_scanpos = xsp;
37119     if (jj_scan_token(190)) {
37120     jj_scanpos = xsp;
37121     if (jj_scan_token(191)) {
37122     jj_scanpos = xsp;
37123     if (jj_scan_token(192)) {
37124     jj_scanpos = xsp;
37125     if (jj_scan_token(194)) {
37126     jj_scanpos = xsp;
37127     if (jj_scan_token(201)) {
37128     jj_scanpos = xsp;
37129     if (jj_scan_token(207)) {
37130     jj_scanpos = xsp;
37131     if (jj_scan_token(215)) {
37132     jj_scanpos = xsp;
37133     if (jj_scan_token(216)) {
37134     jj_scanpos = xsp;
37135     if (jj_scan_token(217)) {
37136     jj_scanpos = xsp;
37137     if (jj_scan_token(218)) {
37138     jj_scanpos = xsp;
37139     if (jj_scan_token(220)) {
37140     jj_scanpos = xsp;
37141     if (jj_scan_token(222)) {
37142     jj_scanpos = xsp;
37143     if (jj_scan_token(221)) {
37144     jj_scanpos = xsp;
37145     if (jj_scan_token(225)) {
37146     jj_scanpos = xsp;
37147     if (jj_scan_token(227)) {
37148     jj_scanpos = xsp;
37149     if (jj_scan_token(246)) {
37150     jj_scanpos = xsp;
37151     if (jj_scan_token(252)) {
37152     jj_scanpos = xsp;
37153     if (jj_scan_token(256)) {
37154     jj_scanpos = xsp;
37155     if (jj_scan_token(259)) {
37156     jj_scanpos = xsp;
37157     if (jj_scan_token(260)) {
37158     jj_scanpos = xsp;
37159     if (jj_scan_token(263)) {
37160     jj_scanpos = xsp;
37161     if (jj_scan_token(267)) {
37162     jj_scanpos = xsp;
37163     if (jj_scan_token(268)) {
37164     jj_scanpos = xsp;
37165     if (jj_scan_token(269)) {
37166     jj_scanpos = xsp;
37167     if (jj_scan_token(282)) {
37168     jj_scanpos = xsp;
37169     if (jj_scan_token(284)) {
37170     jj_scanpos = xsp;
37171     if (jj_scan_token(285)) {
37172     jj_scanpos = xsp;
37173     if (jj_scan_token(298)) {
37174     jj_scanpos = xsp;
37175     if (jj_scan_token(299)) {
37176     jj_scanpos = xsp;
37177     if (jj_scan_token(303)) {
37178     jj_scanpos = xsp;
37179     if (jj_scan_token(305)) {
37180     jj_scanpos = xsp;
37181     if (jj_scan_token(308)) {
37182     jj_scanpos = xsp;
37183     if (jj_scan_token(292)) return true;
37184     }
37185     }
37186     }
37187     }
37188     }
37189     }
37190     }
37191     }
37192     }
37193     }
37194     }
37195     }
37196     }
37197     }
37198     }
37199     }
37200     }
37201     }
37202     }
37203     }
37204     }
37205     }
37206     }
37207     }
37208     }
37209     }
37210     }
37211     }
37212     }
37213     }
37214     }
37215     }
37216     }
37217     }
37218     }
37219     }
37220     }
37221     }
37222     }
37223     }
37224     }
37225     }
37226     }
37227     }
37228     }
37229     }
37230     }
37231     }
37232     }
37233     }
37234     }
37235     }
37236     }
37237     }
37238     }
37239     }
37240     }
37241     }
37242     }
37243     }
37244     }
37245     }
37246     }
37247     }
37248     }
37249     }
37250     }
37251     }
37252     }
37253     return false;
37254   }
37255 
37256   private boolean jj_3R_336() {
37257     if (jj_3R_127()) return true;
37258     return false;
37259   }
37260 
37261   private boolean jj_3R_293() {
37262     Token xsp;
37263     xsp = jj_scanpos;
37264     if (jj_3R_336()) {
37265     jj_scanpos = xsp;
37266     if (jj_scan_token(425)) {
37267     jj_scanpos = xsp;
37268     if (jj_3R_337()) {
37269     jj_scanpos = xsp;
37270     if (jj_3R_338()) {
37271     jj_scanpos = xsp;
37272     if (jj_3R_339()) {
37273     jj_scanpos = xsp;
37274     if (jj_3R_340()) return true;
37275     }
37276     }
37277     }
37278     }
37279     }
37280     return false;
37281   }
37282 
37283   private boolean jj_3R_478() {
37284     if (jj_3R_233()) return true;
37285     return false;
37286   }
37287 
37288   private boolean jj_3R_277() {
37289     if (jj_scan_token(FUNCTION)) return true;
37290     if (jj_3R_154()) return true;
37291     Token xsp;
37292     xsp = jj_scanpos;
37293     if (jj_3R_323()) jj_scanpos = xsp;
37294     xsp = jj_scanpos;
37295     if (jj_3R_324()) jj_scanpos = xsp;
37296     return false;
37297   }
37298 
37299   private boolean jj_3R_477() {
37300     if (jj_3R_182()) return true;
37301     return false;
37302   }
37303 
37304   private boolean jj_3R_624() {
37305     if (jj_scan_token(3)) return true;
37306     if (jj_3R_124()) return true;
37307     return false;
37308   }
37309 
37310   private boolean jj_3R_476() {
37311     if (jj_scan_token(SESSIONTIMEZONE)) return true;
37312     return false;
37313   }
37314 
37315   private boolean jj_3R_193() {
37316     Token xsp;
37317     xsp = jj_scanpos;
37318     if (jj_3R_277()) {
37319     jj_scanpos = xsp;
37320     if (jj_3R_278()) return true;
37321     }
37322     return false;
37323   }
37324 
37325   private boolean jj_3R_623() {
37326     if (jj_scan_token(6)) return true;
37327     if (jj_3R_124()) return true;
37328     return false;
37329   }
37330 
37331   private boolean jj_3R_475() {
37332     if (jj_scan_token(DBTIMEZONE)) return true;
37333     return false;
37334   }
37335 
37336   private boolean jj_3_24() {
37337     Token xsp;
37338     xsp = jj_scanpos;
37339     if (jj_scan_token(207)) {
37340     jj_scanpos = xsp;
37341     if (jj_3R_125()) return true;
37342     }
37343     xsp = jj_scanpos;
37344     if (jj_3_23()) jj_scanpos = xsp;
37345     return false;
37346   }
37347 
37348   private boolean jj_3R_559() {
37349     if (jj_3R_235()) return true;
37350     return false;
37351   }
37352 
37353   private boolean jj_3R_462() {
37354     if (jj_3R_350()) return true;
37355     return false;
37356   }
37357 
37358   private boolean jj_3R_297() {
37359     if (jj_scan_token(TIME)) return true;
37360     if (jj_scan_token(ZONE)) return true;
37361     Token xsp;
37362     xsp = jj_scanpos;
37363     if (jj_3R_475()) {
37364     jj_scanpos = xsp;
37365     if (jj_3R_476()) {
37366     jj_scanpos = xsp;
37367     if (jj_3R_477()) {
37368     jj_scanpos = xsp;
37369     if (jj_3R_478()) return true;
37370     }
37371     }
37372     }
37373     return false;
37374   }
37375 
37376   private boolean jj_3R_600() {
37377     if (jj_scan_token(6)) return true;
37378     if (jj_3R_124()) return true;
37379     Token xsp;
37380     xsp = jj_scanpos;
37381     if (jj_3R_624()) jj_scanpos = xsp;
37382     return false;
37383   }
37384 
37385   private boolean jj_3R_486() {
37386     if (jj_scan_token(3)) return true;
37387     if (jj_3R_124()) return true;
37388     return false;
37389   }
37390 
37391   private boolean jj_3R_470() {
37392     if (jj_3R_146()) return true;
37393     return false;
37394   }
37395 
37396   private boolean jj_3R_225() {
37397     if (jj_3R_298()) return true;
37398     return false;
37399   }
37400 
37401   private boolean jj_3R_296() {
37402     if (jj_scan_token(LOCAL)) return true;
37403     return false;
37404   }
37405 
37406   private boolean jj_3R_469() {
37407     if (jj_3R_118()) return true;
37408     return false;
37409   }
37410 
37411   private boolean jj_3R_237() {
37412     if (jj_3R_282()) return true;
37413     return false;
37414   }
37415 
37416   private boolean jj_3R_425() {
37417     Token xsp;
37418     xsp = jj_scanpos;
37419     if (jj_3R_469()) {
37420     jj_scanpos = xsp;
37421     if (jj_3R_470()) return true;
37422     }
37423     return false;
37424   }
37425 
37426   private boolean jj_3R_597() {
37427     if (jj_scan_token(9)) return true;
37428     if (jj_scan_token(10)) return true;
37429     return false;
37430   }
37431 
37432   private boolean jj_3R_560() {
37433     Token xsp;
37434     xsp = jj_scanpos;
37435     if (jj_3R_597()) {
37436     jj_scanpos = xsp;
37437     if (jj_scan_token(92)) return true;
37438     }
37439     if (jj_3R_233()) return true;
37440     return false;
37441   }
37442 
37443   private boolean jj_3_25() {
37444     Token xsp;
37445     xsp = jj_scanpos;
37446     if (jj_3_24()) {
37447     jj_scanpos = xsp;
37448     if (jj_scan_token(137)) return true;
37449     }
37450     return false;
37451   }
37452 
37453   private boolean jj_3R_599() {
37454     if (jj_scan_token(3)) return true;
37455     if (jj_3R_124()) return true;
37456     return false;
37457   }
37458 
37459   private boolean jj_3R_224() {
37460     if (jj_scan_token(AT)) return true;
37461     Token xsp;
37462     xsp = jj_scanpos;
37463     if (jj_3R_296()) {
37464     jj_scanpos = xsp;
37465     if (jj_3R_297()) return true;
37466     }
37467     return false;
37468   }
37469 
37470   private boolean jj_3R_516() {
37471     if (jj_3R_124()) return true;
37472     return false;
37473   }
37474 
37475   private boolean jj_3R_461() {
37476     if (jj_3R_173()) return true;
37477     return false;
37478   }
37479 
37480   private boolean jj_3R_460() {
37481     if (jj_3R_422()) return true;
37482     return false;
37483   }
37484 
37485   private boolean jj_3R_387() {
37486     if (jj_scan_token(USING)) return true;
37487     if (jj_3R_124()) return true;
37488     Token xsp;
37489     xsp = jj_scanpos;
37490     if (jj_3R_486()) jj_scanpos = xsp;
37491     return false;
37492   }
37493 
37494   private boolean jj_3R_223() {
37495     if (jj_scan_token(2)) return true;
37496     if (jj_3R_120()) return true;
37497     return false;
37498   }
37499 
37500   private boolean jj_3R_142() {
37501     Token xsp;
37502     xsp = jj_scanpos;
37503     if (jj_scan_token(420)) {
37504     jj_scanpos = xsp;
37505     if (jj_scan_token(428)) {
37506     jj_scanpos = xsp;
37507     if (jj_3R_237()) {
37508     jj_scanpos = xsp;
37509     if (jj_scan_token(60)) {
37510     jj_scanpos = xsp;
37511     if (jj_scan_token(171)) {
37512     jj_scanpos = xsp;
37513     if (jj_scan_token(201)) {
37514     jj_scanpos = xsp;
37515     if (jj_scan_token(222)) {
37516     jj_scanpos = xsp;
37517     if (jj_scan_token(227)) {
37518     jj_scanpos = xsp;
37519     if (jj_scan_token(35)) {
37520     jj_scanpos = xsp;
37521     if (jj_scan_token(308)) {
37522     jj_scanpos = xsp;
37523     if (jj_scan_token(258)) {
37524     jj_scanpos = xsp;
37525     if (jj_scan_token(259)) {
37526     jj_scanpos = xsp;
37527     if (jj_scan_token(260)) {
37528     jj_scanpos = xsp;
37529     if (jj_scan_token(269)) {
37530     jj_scanpos = xsp;
37531     if (jj_scan_token(284)) {
37532     jj_scanpos = xsp;
37533     if (jj_scan_token(161)) {
37534     jj_scanpos = xsp;
37535     if (jj_scan_token(303)) {
37536     jj_scanpos = xsp;
37537     if (jj_scan_token(50)) return true;
37538     }
37539     }
37540     }
37541     }
37542     }
37543     }
37544     }
37545     }
37546     }
37547     }
37548     }
37549     }
37550     }
37551     }
37552     }
37553     }
37554     }
37555     return false;
37556   }
37557 
37558   private boolean jj_3R_630() {
37559     if (jj_scan_token(NOT)) return true;
37560     return false;
37561   }
37562 
37563   private boolean jj_3R_474() {
37564     if (jj_3R_124()) return true;
37565     Token xsp;
37566     xsp = jj_scanpos;
37567     if (jj_3_25()) jj_scanpos = xsp;
37568     xsp = jj_scanpos;
37569     if (jj_scan_token(8)) {
37570     jj_scanpos = xsp;
37571     if (jj_3R_559()) return true;
37572     }
37573     xsp = jj_scanpos;
37574     if (jj_3R_560()) jj_scanpos = xsp;
37575     return false;
37576   }
37577 
37578   private boolean jj_3R_222() {
37579     if (jj_scan_token(3)) return true;
37580     if (jj_3R_120()) return true;
37581     return false;
37582   }
37583 
37584   private boolean jj_3R_135() {
37585     Token xsp;
37586     xsp = jj_scanpos;
37587     if (jj_3R_222()) {
37588     jj_scanpos = xsp;
37589     if (jj_3R_223()) {
37590     jj_scanpos = xsp;
37591     if (jj_3R_224()) {
37592     jj_scanpos = xsp;
37593     if (jj_3R_225()) return true;
37594     }
37595     }
37596     }
37597     return false;
37598   }
37599 
37600   private boolean jj_3R_515() {
37601     if (jj_scan_token(3)) return true;
37602     if (jj_3R_124()) return true;
37603     return false;
37604   }
37605 
37606   private boolean jj_3R_331() {
37607     if (jj_3R_191()) return true;
37608     if (jj_scan_token(BEGIN)) return true;
37609     Token xsp;
37610     xsp = jj_scanpos;
37611     if (jj_3R_460()) jj_scanpos = xsp;
37612     while (true) {
37613       xsp = jj_scanpos;
37614       if (jj_3R_461()) { jj_scanpos = xsp; break; }
37615     }
37616     xsp = jj_scanpos;
37617     if (jj_3R_462()) jj_scanpos = xsp;
37618     if (jj_scan_token(END)) return true;
37619     xsp = jj_scanpos;
37620     if (jj_3R_463()) jj_scanpos = xsp;
37621     return false;
37622   }
37623 
37624   private boolean jj_3_22() {
37625     if (jj_3R_124()) return true;
37626     if (jj_scan_token(3)) return true;
37627     return false;
37628   }
37629 
37630   private boolean jj_3_21() {
37631     if (jj_3R_123()) return true;
37632     return false;
37633   }
37634 
37635   private boolean jj_3_56() {
37636     Token xsp;
37637     if (jj_scan_token(5)) return true;
37638     while (true) {
37639       xsp = jj_scanpos;
37640       if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37641     }
37642     if (jj_scan_token(WITH)) return true;
37643     return false;
37644   }
37645 
37646   private boolean jj_3R_154() {
37647     Token xsp;
37648     xsp = jj_scanpos;
37649     if (jj_3_22()) jj_scanpos = xsp;
37650     if (jj_3R_124()) return true;
37651     return false;
37652   }
37653 
37654   private boolean jj_3_55() {
37655     if (jj_scan_token(WITH)) return true;
37656     return false;
37657   }
37658 
37659   private boolean jj_3_54() {
37660     Token xsp;
37661     if (jj_scan_token(5)) return true;
37662     while (true) {
37663       xsp = jj_scanpos;
37664       if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37665     }
37666     if (jj_scan_token(SELECT)) return true;
37667     return false;
37668   }
37669 
37670   private boolean jj_3_53() {
37671     if (jj_scan_token(SELECT)) return true;
37672     return false;
37673   }
37674 
37675   private boolean jj_3R_295() {
37676     if (jj_scan_token(6)) return true;
37677     if (jj_3R_233()) return true;
37678     return false;
37679   }
37680 
37681   private boolean jj_3R_389() {
37682     if (jj_scan_token(RELIES_ON)) return true;
37683     if (jj_scan_token(5)) return true;
37684     if (jj_3R_124()) return true;
37685     Token xsp;
37686     xsp = jj_scanpos;
37687     if (jj_3R_599()) jj_scanpos = xsp;
37688     while (true) {
37689       xsp = jj_scanpos;
37690       if (jj_3R_600()) { jj_scanpos = xsp; break; }
37691     }
37692     if (jj_scan_token(7)) return true;
37693     return false;
37694   }
37695 
37696   private boolean jj_3R_386() {
37697     if (jj_3R_428()) return true;
37698     return false;
37699   }
37700 
37701   private boolean jj_3_52() {
37702     if (jj_3R_139()) return true;
37703     return false;
37704   }
37705 
37706   private boolean jj_3_51() {
37707     if (jj_3R_138()) return true;
37708     return false;
37709   }
37710 
37711   private boolean jj_3R_221() {
37712     if (jj_scan_token(5)) return true;
37713     if (jj_3R_233()) return true;
37714     Token xsp;
37715     while (true) {
37716       xsp = jj_scanpos;
37717       if (jj_3R_295()) { jj_scanpos = xsp; break; }
37718     }
37719     if (jj_scan_token(7)) return true;
37720     return false;
37721   }
37722 
37723   private boolean jj_3_50() {
37724     if (jj_3R_137()) return true;
37725     return false;
37726   }
37727 
37728   private boolean jj_3_49() {
37729     if (jj_3R_136()) return true;
37730     return false;
37731   }
37732 
37733   private boolean jj_3R_430() {
37734     Token xsp;
37735     xsp = jj_scanpos;
37736     if (jj_scan_token(204)) {
37737     jj_scanpos = xsp;
37738     if (jj_scan_token(71)) return true;
37739     }
37740     xsp = jj_scanpos;
37741     if (jj_3R_516()) jj_scanpos = xsp;
37742     if (jj_scan_token(BY)) return true;
37743     if (jj_scan_token(5)) return true;
37744     if (jj_3R_124()) return true;
37745     while (true) {
37746       xsp = jj_scanpos;
37747       if (jj_3R_623()) { jj_scanpos = xsp; break; }
37748     }
37749     if (jj_scan_token(7)) return true;
37750     return false;
37751   }
37752 
37753   private boolean jj_3R_220() {
37754     if (jj_scan_token(5)) return true;
37755     if (jj_3R_179()) return true;
37756     if (jj_scan_token(7)) return true;
37757     return false;
37758   }
37759 
37760   private boolean jj_3R_281() {
37761     Token xsp;
37762     xsp = jj_scanpos;
37763     if (jj_scan_token(152)) {
37764     jj_scanpos = xsp;
37765     if (jj_scan_token(51)) return true;
37766     }
37767     xsp = jj_scanpos;
37768     if (jj_3_21()) {
37769     jj_scanpos = xsp;
37770     if (jj_3R_331()) return true;
37771     }
37772     return false;
37773   }
37774 
37775   private boolean jj_3R_219() {
37776     if (jj_scan_token(WITH)) return true;
37777     if (jj_3R_179()) return true;
37778     return false;
37779   }
37780 
37781   private boolean jj_3R_429() {
37782     if (jj_scan_token(USING)) return true;
37783     if (jj_3R_124()) return true;
37784     Token xsp;
37785     xsp = jj_scanpos;
37786     if (jj_3R_515()) jj_scanpos = xsp;
37787     return false;
37788   }
37789 
37790   private boolean jj_3R_388() {
37791     Token xsp;
37792     xsp = jj_scanpos;
37793     if (jj_3R_429()) {
37794     jj_scanpos = xsp;
37795     if (jj_3R_430()) return true;
37796     }
37797     return false;
37798   }
37799 
37800   private boolean jj_3R_218() {
37801     if (jj_scan_token(5)) return true;
37802     if (jj_3R_179()) return true;
37803     if (jj_scan_token(7)) return true;
37804     return false;
37805   }
37806 
37807   private boolean jj_3R_217() {
37808     if (jj_scan_token(SELECT)) return true;
37809     if (jj_3R_179()) return true;
37810     return false;
37811   }
37812 
37813   private boolean jj_3R_216() {
37814     if (jj_3R_294()) return true;
37815     return false;
37816   }
37817 
37818   private boolean jj_3R_215() {
37819     if (jj_3R_139()) return true;
37820     return false;
37821   }
37822 
37823   private boolean jj_3R_276() {
37824     Token xsp;
37825     xsp = jj_scanpos;
37826     if (jj_scan_token(100)) {
37827     jj_scanpos = xsp;
37828     if (jj_scan_token(182)) return true;
37829     }
37830     return false;
37831   }
37832 
37833   private boolean jj_3R_214() {
37834     if (jj_3R_138()) return true;
37835     return false;
37836   }
37837 
37838   private boolean jj_3R_213() {
37839     if (jj_3R_137()) return true;
37840     return false;
37841   }
37842 
37843   private boolean jj_3R_212() {
37844     if (jj_3R_136()) return true;
37845     return false;
37846   }
37847 
37848   private boolean jj_3R_211() {
37849     if (jj_3R_293()) return true;
37850     return false;
37851   }
37852 
37853   private boolean jj_3R_280() {
37854     if (jj_scan_token(AGGREGATE)) return true;
37855     if (jj_scan_token(USING)) return true;
37856     if (jj_3R_124()) return true;
37857     return false;
37858   }
37859 
37860   private boolean jj_3R_330() {
37861     if (jj_scan_token(RESULT_CACHE)) return true;
37862     Token xsp;
37863     xsp = jj_scanpos;
37864     if (jj_3R_389()) jj_scanpos = xsp;
37865     return false;
37866   }
37867 
37868   private boolean jj_3R_134() {
37869     Token xsp;
37870     xsp = jj_scanpos;
37871     if (jj_3R_211()) {
37872     jj_scanpos = xsp;
37873     if (jj_3R_212()) {
37874     jj_scanpos = xsp;
37875     if (jj_3R_213()) {
37876     jj_scanpos = xsp;
37877     if (jj_3R_214()) {
37878     jj_scanpos = xsp;
37879     if (jj_3R_215()) {
37880     jj_scanpos = xsp;
37881     if (jj_3R_216()) {
37882     jj_scanpos = xsp;
37883     if (jj_3R_217()) {
37884     jj_scanpos = xsp;
37885     if (jj_3R_218()) {
37886     jj_scanpos = xsp;
37887     if (jj_3R_219()) {
37888     jj_scanpos = xsp;
37889     if (jj_3R_220()) {
37890     jj_scanpos = xsp;
37891     if (jj_3R_221()) return true;
37892     }
37893     }
37894     }
37895     }
37896     }
37897     }
37898     }
37899     }
37900     }
37901     }
37902     return false;
37903   }
37904 
37905   private boolean jj_3_48() {
37906     if (jj_3R_135()) return true;
37907     return false;
37908   }
37909 
37910   private boolean jj_3_47() {
37911     if (jj_scan_token(NEW)) return true;
37912     if (jj_3R_134()) return true;
37913     return false;
37914   }
37915 
37916   private boolean jj_3R_292() {
37917     if (jj_3R_134()) return true;
37918     return false;
37919   }
37920 
37921   private boolean jj_3R_329() {
37922     if (jj_scan_token(PIPELINED)) return true;
37923     Token xsp;
37924     xsp = jj_scanpos;
37925     if (jj_3R_388()) jj_scanpos = xsp;
37926     return false;
37927   }
37928 
37929   private boolean jj_3R_328() {
37930     if (jj_scan_token(PARALLEL_ENABLE)) return true;
37931     Token xsp;
37932     xsp = jj_scanpos;
37933     if (jj_3R_386()) jj_scanpos = xsp;
37934     xsp = jj_scanpos;
37935     if (jj_3R_387()) jj_scanpos = xsp;
37936     return false;
37937   }
37938 
37939   private boolean jj_3R_327() {
37940     if (jj_3R_238()) return true;
37941     return false;
37942   }
37943 
37944   private boolean jj_3R_279() {
37945     Token xsp;
37946     xsp = jj_scanpos;
37947     if (jj_3R_326()) {
37948     jj_scanpos = xsp;
37949     if (jj_scan_token(95)) {
37950     jj_scanpos = xsp;
37951     if (jj_3R_327()) {
37952     jj_scanpos = xsp;
37953     if (jj_3R_328()) {
37954     jj_scanpos = xsp;
37955     if (jj_3R_329()) {
37956     jj_scanpos = xsp;
37957     if (jj_3R_330()) return true;
37958     }
37959     }
37960     }
37961     }
37962     }
37963     return false;
37964   }
37965 
37966   private boolean jj_3R_326() {
37967     if (jj_scan_token(AUTHID)) return true;
37968     Token xsp;
37969     xsp = jj_scanpos;
37970     if (jj_scan_token(37)) {
37971     jj_scanpos = xsp;
37972     if (jj_scan_token(36)) return true;
37973     }
37974     return false;
37975   }
37976 
37977   private boolean jj_3R_195() {
37978     Token xsp;
37979     while (true) {
37980       xsp = jj_scanpos;
37981       if (jj_3R_279()) { jj_scanpos = xsp; break; }
37982     }
37983     xsp = jj_scanpos;
37984     if (jj_3R_280()) jj_scanpos = xsp;
37985     xsp = jj_scanpos;
37986     if (jj_3R_281()) jj_scanpos = xsp;
37987     if (jj_scan_token(4)) return true;
37988     return false;
37989   }
37990 
37991   private boolean jj_3R_275() {
37992     if (jj_scan_token(OR)) return true;
37993     if (jj_scan_token(REPLACE)) return true;
37994     return false;
37995   }
37996 
37997   private boolean jj_3R_291() {
37998     if (jj_scan_token(NEW)) return true;
37999     if (jj_3R_134()) return true;
38000     return false;
38001   }
38002 
38003   private boolean jj_3R_631() {
38004     if (jj_scan_token(6)) return true;
38005     Token xsp;
38006     xsp = jj_scanpos;
38007     if (jj_scan_token(198)) jj_scanpos = xsp;
38008     if (jj_3R_294()) return true;
38009     return false;
38010   }
38011 
38012   private boolean jj_3R_210() {
38013     Token xsp;
38014     xsp = jj_scanpos;
38015     if (jj_3R_291()) {
38016     jj_scanpos = xsp;
38017     if (jj_3R_292()) return true;
38018     }
38019     while (true) {
38020       xsp = jj_scanpos;
38021       if (jj_3_48()) { jj_scanpos = xsp; break; }
38022     }
38023     return false;
38024   }
38025 
38026   private boolean jj_3R_194() {
38027     if (jj_3R_248()) return true;
38028     return false;
38029   }
38030 
38031   private boolean jj_3R_209() {
38032     if (jj_scan_token(NEW_DOT)) return true;
38033     if (jj_3R_120()) return true;
38034     return false;
38035   }
38036 
38037   private boolean jj_3R_192() {
38038     if (jj_scan_token(CREATE)) return true;
38039     Token xsp;
38040     xsp = jj_scanpos;
38041     if (jj_3R_275()) jj_scanpos = xsp;
38042     xsp = jj_scanpos;
38043     if (jj_3R_276()) jj_scanpos = xsp;
38044     return false;
38045   }
38046 
38047   private boolean jj_3R_133() {
38048     Token xsp;
38049     xsp = jj_scanpos;
38050     if (jj_3R_209()) {
38051     jj_scanpos = xsp;
38052     if (jj_3R_210()) return true;
38053     }
38054     return false;
38055   }
38056 
38057   private boolean jj_3R_118() {
38058     Token xsp;
38059     xsp = jj_scanpos;
38060     if (jj_3R_192()) jj_scanpos = xsp;
38061     if (jj_3R_193()) return true;
38062     xsp = jj_scanpos;
38063     if (jj_3R_194()) {
38064     jj_scanpos = xsp;
38065     if (jj_3R_195()) return true;
38066     }
38067     return false;
38068   }
38069 
38070   private boolean jj_3_46() {
38071     if (jj_scan_token(IDENTIFIER)) return true;
38072     if (jj_scan_token(IS)) return true;
38073     return false;
38074   }
38075 
38076   private boolean jj_3R_626() {
38077     if (jj_3R_133()) return true;
38078     return false;
38079   }
38080 
38081   private boolean jj_3R_534() {
38082     if (jj_scan_token(CC_ERROR)) return true;
38083     if (jj_3R_233()) return true;
38084     if (jj_scan_token(CC_END)) return true;
38085     return false;
38086   }
38087 
38088   private boolean jj_3R_625() {
38089     if (jj_3R_294()) return true;
38090     if (jj_scan_token(IS)) return true;
38091     Token xsp;
38092     xsp = jj_scanpos;
38093     if (jj_3R_630()) jj_scanpos = xsp;
38094     if (jj_scan_token(OF)) return true;
38095     xsp = jj_scanpos;
38096     if (jj_scan_token(284)) jj_scanpos = xsp;
38097     if (jj_scan_token(5)) return true;
38098     xsp = jj_scanpos;
38099     if (jj_scan_token(198)) jj_scanpos = xsp;
38100     if (jj_3R_294()) return true;
38101     while (true) {
38102       xsp = jj_scanpos;
38103       if (jj_3R_631()) { jj_scanpos = xsp; break; }
38104     }
38105     if (jj_scan_token(7)) return true;
38106     return false;
38107   }
38108 
38109   private boolean jj_3R_533() {
38110     if (jj_3R_322()) return true;
38111     return false;
38112   }
38113 
38114   private boolean jj_3R_505() {
38115     Token xsp;
38116     xsp = jj_scanpos;
38117     if (jj_3R_533()) {
38118     jj_scanpos = xsp;
38119     if (jj_3R_534()) return true;
38120     }
38121     return false;
38122   }
38123 
38124   private boolean jj_3R_614() {
38125     Token xsp;
38126     xsp = jj_scanpos;
38127     if (jj_3R_625()) {
38128     jj_scanpos = xsp;
38129     if (jj_3R_626()) return true;
38130     }
38131     return false;
38132   }
38133 
38134   private boolean jj_3R_473() {
38135     if (jj_scan_token(CC_ELSE)) return true;
38136     Token xsp;
38137     while (true) {
38138       xsp = jj_scanpos;
38139       if (jj_3R_505()) { jj_scanpos = xsp; break; }
38140     }
38141     return false;
38142   }
38143 
38144   private boolean jj_3R_532() {
38145     if (jj_scan_token(CC_ERROR)) return true;
38146     if (jj_3R_233()) return true;
38147     if (jj_scan_token(CC_END)) return true;
38148     return false;
38149   }
38150 
38151   private boolean jj_3R_531() {
38152     if (jj_3R_322()) return true;
38153     return false;
38154   }
38155 
38156   private boolean jj_3R_504() {
38157     Token xsp;
38158     xsp = jj_scanpos;
38159     if (jj_3R_531()) {
38160     jj_scanpos = xsp;
38161     if (jj_3R_532()) return true;
38162     }
38163     return false;
38164   }
38165 
38166   private boolean jj_3R_589() {
38167     if (jj_3R_614()) return true;
38168     return false;
38169   }
38170 
38171   private boolean jj_3R_472() {
38172     if (jj_scan_token(CC_ELSIF)) return true;
38173     if (jj_3R_343()) return true;
38174     if (jj_scan_token(CC_THEN)) return true;
38175     Token xsp;
38176     while (true) {
38177       xsp = jj_scanpos;
38178       if (jj_3R_504()) { jj_scanpos = xsp; break; }
38179     }
38180     return false;
38181   }
38182 
38183   private boolean jj_3R_503() {
38184     if (jj_scan_token(CC_ERROR)) return true;
38185     if (jj_3R_233()) return true;
38186     if (jj_scan_token(CC_END)) return true;
38187     return false;
38188   }
38189 
38190   private boolean jj_3R_253() {
38191     if (jj_3R_124()) return true;
38192     return false;
38193   }
38194 
38195   private boolean jj_3R_588() {
38196     if (jj_scan_token(NOT)) return true;
38197     if (jj_3R_483()) return true;
38198     return false;
38199   }
38200 
38201   private boolean jj_3R_502() {
38202     if (jj_3R_322()) return true;
38203     return false;
38204   }
38205 
38206   private boolean jj_3R_471() {
38207     Token xsp;
38208     xsp = jj_scanpos;
38209     if (jj_3R_502()) {
38210     jj_scanpos = xsp;
38211     if (jj_3R_503()) return true;
38212     }
38213     return false;
38214   }
38215 
38216   private boolean jj_3R_544() {
38217     Token xsp;
38218     xsp = jj_scanpos;
38219     if (jj_3R_588()) {
38220     jj_scanpos = xsp;
38221     if (jj_3R_589()) return true;
38222     }
38223     return false;
38224   }
38225 
38226   private boolean jj_3R_426() {
38227     if (jj_scan_token(CC_IF)) return true;
38228     if (jj_3R_343()) return true;
38229     if (jj_scan_token(CC_THEN)) return true;
38230     Token xsp;
38231     while (true) {
38232       xsp = jj_scanpos;
38233       if (jj_3R_471()) { jj_scanpos = xsp; break; }
38234     }
38235     while (true) {
38236       xsp = jj_scanpos;
38237       if (jj_3R_472()) { jj_scanpos = xsp; break; }
38238     }
38239     while (true) {
38240       xsp = jj_scanpos;
38241       if (jj_3R_473()) { jj_scanpos = xsp; break; }
38242     }
38243     if (jj_scan_token(CC_END)) return true;
38244     return false;
38245   }
38246 
38247   private boolean jj_3R_513() {
38248     if (jj_3R_544()) return true;
38249     return false;
38250   }
38251 
38252   private boolean jj_3R_274() {
38253     if (jj_3R_322()) return true;
38254     return false;
38255   }
38256 
38257   private boolean jj_3R_543() {
38258     if (jj_scan_token(17)) return true;
38259     return false;
38260   }
38261 
38262   private boolean jj_3R_542() {
38263     if (jj_scan_token(16)) return true;
38264     return false;
38265   }
38266 
38267   private boolean jj_3R_512() {
38268     Token xsp;
38269     xsp = jj_scanpos;
38270     if (jj_3R_542()) {
38271     jj_scanpos = xsp;
38272     if (jj_3R_543()) return true;
38273     }
38274     if (jj_3R_483()) return true;
38275     return false;
38276   }
38277 
38278   private boolean jj_3R_483() {
38279     Token xsp;
38280     xsp = jj_scanpos;
38281     if (jj_3R_512()) {
38282     jj_scanpos = xsp;
38283     if (jj_3R_513()) return true;
38284     }
38285     return false;
38286   }
38287 
38288   private boolean jj_3R_384() {
38289     if (jj_3R_426()) return true;
38290     return false;
38291   }
38292 
38293   private boolean jj_3R_191() {
38294     Token xsp;
38295     while (true) {
38296       xsp = jj_scanpos;
38297       if (jj_3R_274()) { jj_scanpos = xsp; break; }
38298     }
38299     return false;
38300   }
38301 
38302   private boolean jj_3R_383() {
38303     if (jj_3R_425()) return true;
38304     return false;
38305   }
38306 
38307   private boolean jj_3_18() {
38308     Token xsp;
38309     xsp = jj_scanpos;
38310     if (jj_scan_token(125)) {
38311     jj_scanpos = xsp;
38312     if (jj_scan_token(223)) return true;
38313     }
38314     if (jj_3R_120()) return true;
38315     return false;
38316   }
38317 
38318   private boolean jj_3_17() {
38319     Token xsp;
38320     xsp = jj_scanpos;
38321     if (jj_scan_token(284)) {
38322     jj_scanpos = xsp;
38323     if (jj_scan_token(264)) return true;
38324     }
38325     if (jj_3R_120()) return true;
38326     xsp = jj_scanpos;
38327     if (jj_scan_token(152)) {
38328     jj_scanpos = xsp;
38329     if (jj_scan_token(51)) return true;
38330     }
38331     return false;
38332   }
38333 
38334   private boolean jj_3R_382() {
38335     if (jj_3R_424()) return true;
38336     return false;
38337   }
38338 
38339   private boolean jj_3R_381() {
38340     if (jj_3R_423()) return true;
38341     return false;
38342   }
38343 
38344   private boolean jj_3R_607() {
38345     if (jj_scan_token(MOD)) return true;
38346     return false;
38347   }
38348 
38349   private boolean jj_3_20() {
38350     if (jj_3R_122()) return true;
38351     return false;
38352   }
38353 
38354   private boolean jj_3R_606() {
38355     if (jj_scan_token(1)) return true;
38356     return false;
38357   }
38358 
38359   private boolean jj_3R_306() {
38360     if (jj_3R_350()) return true;
38361     return false;
38362   }
38363 
38364   private boolean jj_3R_605() {
38365     if (jj_scan_token(20)) return true;
38366     return false;
38367   }
38368 
38369   private boolean jj_3_19() {
38370     if (jj_3R_121()) return true;
38371     return false;
38372   }
38373 
38374   private boolean jj_3R_604() {
38375     if (jj_scan_token(19)) return true;
38376     return false;
38377   }
38378 
38379   private boolean jj_3R_380() {
38380     if (jj_3R_118()) return true;
38381     return false;
38382   }
38383 
38384   private boolean jj_3R_569() {
38385     Token xsp;
38386     xsp = jj_scanpos;
38387     if (jj_3R_604()) {
38388     jj_scanpos = xsp;
38389     if (jj_3R_605()) {
38390     jj_scanpos = xsp;
38391     if (jj_3R_606()) {
38392     jj_scanpos = xsp;
38393     if (jj_3R_607()) return true;
38394     }
38395     }
38396     }
38397     if (jj_3R_483()) return true;
38398     return false;
38399   }
38400 
38401   private boolean jj_3R_379() {
38402     if (jj_3R_152()) return true;
38403     return false;
38404   }
38405 
38406   private boolean jj_3_16() {
38407     if (jj_3R_119()) return true;
38408     return false;
38409   }
38410 
38411   private boolean jj_3R_378() {
38412     if (jj_3R_422()) return true;
38413     return false;
38414   }
38415 
38416   private boolean jj_3R_536() {
38417     if (jj_3R_483()) return true;
38418     Token xsp;
38419     while (true) {
38420       xsp = jj_scanpos;
38421       if (jj_3R_569()) { jj_scanpos = xsp; break; }
38422     }
38423     return false;
38424   }
38425 
38426   private boolean jj_3_15() {
38427     if (jj_3R_118()) return true;
38428     return false;
38429   }
38430 
38431   private boolean jj_3R_251() {
38432     Token xsp;
38433     xsp = jj_scanpos;
38434     if (jj_scan_token(100)) {
38435     jj_scanpos = xsp;
38436     if (jj_scan_token(182)) return true;
38437     }
38438     return false;
38439   }
38440 
38441   private boolean jj_3R_305() {
38442     if (jj_3R_173()) return true;
38443     return false;
38444   }
38445 
38446   private boolean jj_3R_299() {
38447     if (jj_scan_token(18)) return true;
38448     if (jj_3R_133()) return true;
38449     return false;
38450   }
38451 
38452   private boolean jj_3R_322() {
38453     Token xsp;
38454     xsp = jj_scanpos;
38455     if (jj_3R_378()) {
38456     jj_scanpos = xsp;
38457     if (jj_3_16()) {
38458     jj_scanpos = xsp;
38459     if (jj_3R_379()) {
38460     jj_scanpos = xsp;
38461     if (jj_3R_380()) {
38462     jj_scanpos = xsp;
38463     if (jj_3_19()) {
38464     jj_scanpos = xsp;
38465     if (jj_3_20()) {
38466     jj_scanpos = xsp;
38467     if (jj_3R_381()) {
38468     jj_scanpos = xsp;
38469     if (jj_3R_382()) {
38470     jj_scanpos = xsp;
38471     if (jj_3R_383()) {
38472     jj_scanpos = xsp;
38473     if (jj_3R_384()) return true;
38474     }
38475     }
38476     }
38477     }
38478     }
38479     }
38480     }
38481     }
38482     }
38483     return false;
38484   }
38485 
38486   private boolean jj_3R_252() {
38487     if (jj_scan_token(BEGIN)) return true;
38488     Token xsp;
38489     while (true) {
38490       xsp = jj_scanpos;
38491       if (jj_3R_305()) { jj_scanpos = xsp; break; }
38492     }
38493     xsp = jj_scanpos;
38494     if (jj_3R_306()) jj_scanpos = xsp;
38495     return false;
38496   }
38497 
38498   private boolean jj_3R_229() {
38499     if (jj_3R_133()) return true;
38500     Token xsp;
38501     while (true) {
38502       xsp = jj_scanpos;
38503       if (jj_3R_299()) { jj_scanpos = xsp; break; }
38504     }
38505     return false;
38506   }
38507 
38508   private boolean jj_3R_250() {
38509     if (jj_scan_token(OR)) return true;
38510     if (jj_scan_token(REPLACE)) return true;
38511     return false;
38512   }
38513 
38514   private boolean jj_3R_160() {
38515     Token xsp;
38516     xsp = jj_scanpos;
38517     if (jj_scan_token(152)) {
38518     jj_scanpos = xsp;
38519     if (jj_scan_token(51)) return true;
38520     }
38521     if (jj_3R_191()) return true;
38522     xsp = jj_scanpos;
38523     if (jj_3R_252()) jj_scanpos = xsp;
38524     if (jj_scan_token(END)) return true;
38525     xsp = jj_scanpos;
38526     if (jj_3R_253()) jj_scanpos = xsp;
38527     if (jj_scan_token(4)) return true;
38528     return false;
38529   }
38530 
38531   private boolean jj_3R_572() {
38532     if (jj_scan_token(18)) return true;
38533     return false;
38534   }
38535 
38536   private boolean jj_3R_571() {
38537     if (jj_scan_token(17)) return true;
38538     return false;
38539   }
38540 
38541   private boolean jj_3R_159() {
38542     if (jj_3R_248()) return true;
38543     return false;
38544   }
38545 
38546   private boolean jj_3R_570() {
38547     if (jj_scan_token(16)) return true;
38548     return false;
38549   }
38550 
38551   private boolean jj_3R_270() {
38552     if (jj_3R_190()) return true;
38553     return false;
38554   }
38555 
38556   private boolean jj_3R_537() {
38557     Token xsp;
38558     xsp = jj_scanpos;
38559     if (jj_3R_570()) {
38560     jj_scanpos = xsp;
38561     if (jj_3R_571()) {
38562     jj_scanpos = xsp;
38563     if (jj_3R_572()) return true;
38564     }
38565     }
38566     if (jj_3R_536()) return true;
38567     return false;
38568   }
38569 
38570   private boolean jj_3R_158() {
38571     if (jj_scan_token(CREATE)) return true;
38572     Token xsp;
38573     xsp = jj_scanpos;
38574     if (jj_3R_250()) jj_scanpos = xsp;
38575     xsp = jj_scanpos;
38576     if (jj_3R_251()) jj_scanpos = xsp;
38577     return false;
38578   }
38579 
38580   private boolean jj_3R_245() {
38581     Token xsp;
38582     xsp = jj_scanpos;
38583     if (jj_scan_token(100)) {
38584     jj_scanpos = xsp;
38585     if (jj_scan_token(182)) return true;
38586     }
38587     return false;
38588   }
38589 
38590   private boolean jj_3R_249() {
38591     if (jj_3R_124()) return true;
38592     return false;
38593   }
38594 
38595   private boolean jj_3R_507() {
38596     if (jj_3R_536()) return true;
38597     Token xsp;
38598     while (true) {
38599       xsp = jj_scanpos;
38600       if (jj_3R_537()) { jj_scanpos = xsp; break; }
38601     }
38602     return false;
38603   }
38604 
38605   private boolean jj_3R_587() {
38606     if (jj_3R_182()) return true;
38607     return false;
38608   }
38609 
38610   private boolean jj_3R_104() {
38611     Token xsp;
38612     xsp = jj_scanpos;
38613     if (jj_3R_158()) jj_scanpos = xsp;
38614     xsp = jj_scanpos;
38615     if (jj_scan_token(209)) {
38616     jj_scanpos = xsp;
38617     if (jj_scan_token(284)) return true;
38618     }
38619     if (jj_scan_token(BODY)) return true;
38620     if (jj_3R_154()) return true;
38621     xsp = jj_scanpos;
38622     if (jj_3R_159()) {
38623     jj_scanpos = xsp;
38624     if (jj_3R_160()) return true;
38625     }
38626     return false;
38627   }
38628 
38629   private boolean jj_3R_586() {
38630     if (jj_scan_token(CHARACTER_LITERAL)) return true;
38631     return false;
38632   }
38633 
38634   private boolean jj_3R_541() {
38635     if (jj_scan_token(ESCAPE)) return true;
38636     Token xsp;
38637     xsp = jj_scanpos;
38638     if (jj_3R_586()) {
38639     jj_scanpos = xsp;
38640     if (jj_3R_587()) return true;
38641     }
38642     return false;
38643   }
38644 
38645   private boolean jj_3R_613() {
38646     if (jj_scan_token(ALL)) return true;
38647     return false;
38648   }
38649 
38650   private boolean jj_3R_612() {
38651     if (jj_scan_token(DISTINCT)) return true;
38652     return false;
38653   }
38654 
38655   private boolean jj_3R_585() {
38656     Token xsp;
38657     xsp = jj_scanpos;
38658     if (jj_3R_612()) {
38659     jj_scanpos = xsp;
38660     if (jj_3R_613()) return true;
38661     }
38662     return false;
38663   }
38664 
38665   private boolean jj_3R_157() {
38666     Token xsp;
38667     xsp = jj_scanpos;
38668     if (jj_scan_token(152)) {
38669     jj_scanpos = xsp;
38670     if (jj_scan_token(51)) return true;
38671     }
38672     if (jj_3R_191()) return true;
38673     if (jj_scan_token(END)) return true;
38674     xsp = jj_scanpos;
38675     if (jj_3R_249()) jj_scanpos = xsp;
38676     if (jj_scan_token(4)) return true;
38677     return false;
38678   }
38679 
38680   private boolean jj_3R_584() {
38681     if (jj_scan_token(UNION)) return true;
38682     return false;
38683   }
38684 
38685   private boolean jj_3R_583() {
38686     if (jj_scan_token(INTERSECT)) return true;
38687     return false;
38688   }
38689 
38690   private boolean jj_3R_582() {
38691     if (jj_scan_token(EXCEPT)) return true;
38692     return false;
38693   }
38694 
38695   private boolean jj_3R_156() {
38696     if (jj_3R_248()) return true;
38697     return false;
38698   }
38699 
38700   private boolean jj_3R_244() {
38701     if (jj_scan_token(OR)) return true;
38702     if (jj_scan_token(REPLACE)) return true;
38703     return false;
38704   }
38705 
38706   private boolean jj_3R_247() {
38707     if (jj_3R_238()) return true;
38708     return false;
38709   }
38710 
38711   private boolean jj_3R_611() {
38712     if (jj_scan_token(OF)) return true;
38713     return false;
38714   }
38715 
38716   private boolean jj_3R_155() {
38717     Token xsp;
38718     xsp = jj_scanpos;
38719     if (jj_3R_246()) {
38720     jj_scanpos = xsp;
38721     if (jj_3R_247()) return true;
38722     }
38723     return false;
38724   }
38725 
38726   private boolean jj_3R_246() {
38727     if (jj_scan_token(AUTHID)) return true;
38728     Token xsp;
38729     xsp = jj_scanpos;
38730     if (jj_scan_token(37)) {
38731     jj_scanpos = xsp;
38732     if (jj_scan_token(36)) return true;
38733     }
38734     return false;
38735   }
38736 
38737   private boolean jj_3R_540() {
38738     if (jj_scan_token(MULTISET)) return true;
38739     Token xsp;
38740     xsp = jj_scanpos;
38741     if (jj_3R_582()) {
38742     jj_scanpos = xsp;
38743     if (jj_3R_583()) {
38744     jj_scanpos = xsp;
38745     if (jj_3R_584()) return true;
38746     }
38747     }
38748     xsp = jj_scanpos;
38749     if (jj_3R_585()) jj_scanpos = xsp;
38750     return false;
38751   }
38752 
38753   private boolean jj_3R_610() {
38754     if (jj_scan_token(SUBMULTISET)) return true;
38755     return false;
38756   }
38757 
38758   private boolean jj_3R_201() {
38759     if (jj_3R_282()) return true;
38760     return false;
38761   }
38762 
38763   private boolean jj_3R_609() {
38764     if (jj_scan_token(MEMBER)) return true;
38765     return false;
38766   }
38767 
38768   private boolean jj_3R_153() {
38769     if (jj_scan_token(CREATE)) return true;
38770     Token xsp;
38771     xsp = jj_scanpos;
38772     if (jj_3R_244()) jj_scanpos = xsp;
38773     xsp = jj_scanpos;
38774     if (jj_3R_245()) jj_scanpos = xsp;
38775     return false;
38776   }
38777 
38778   private boolean jj_3R_103() {
38779     Token xsp;
38780     xsp = jj_scanpos;
38781     if (jj_3R_153()) jj_scanpos = xsp;
38782     if (jj_scan_token(PACKAGE)) return true;
38783     if (jj_3R_154()) return true;
38784     while (true) {
38785       xsp = jj_scanpos;
38786       if (jj_3R_155()) { jj_scanpos = xsp; break; }
38787     }
38788     xsp = jj_scanpos;
38789     if (jj_3R_156()) {
38790     jj_scanpos = xsp;
38791     if (jj_3R_157()) return true;
38792     }
38793     return false;
38794   }
38795 
38796   private boolean jj_3R_581() {
38797     Token xsp;
38798     xsp = jj_scanpos;
38799     if (jj_3R_609()) {
38800     jj_scanpos = xsp;
38801     if (jj_3R_610()) return true;
38802     }
38803     xsp = jj_scanpos;
38804     if (jj_3R_611()) jj_scanpos = xsp;
38805     return false;
38806   }
38807 
38808   private boolean jj_3R_580() {
38809     if (jj_scan_token(FROM)) return true;
38810     return false;
38811   }
38812 
38813   private boolean jj_3R_579() {
38814     if (jj_scan_token(LIKE)) return true;
38815     return false;
38816   }
38817 
38818   private boolean jj_3R_578() {
38819     if (jj_scan_token(BETWEEN)) return true;
38820     return false;
38821   }
38822 
38823   private boolean jj_3R_117() {
38824     if (jj_scan_token(DECLARE)) return true;
38825     if (jj_3R_191()) return true;
38826     return false;
38827   }
38828 
38829   private boolean jj_3R_124() {
38830     Token xsp;
38831     xsp = jj_scanpos;
38832     if (jj_scan_token(420)) {
38833     jj_scanpos = xsp;
38834     if (jj_scan_token(428)) {
38835     jj_scanpos = xsp;
38836     if (jj_3R_201()) {
38837     jj_scanpos = xsp;
38838     if (jj_scan_token(35)) {
38839     jj_scanpos = xsp;
38840     if (jj_scan_token(38)) {
38841     jj_scanpos = xsp;
38842     if (jj_scan_token(39)) {
38843     jj_scanpos = xsp;
38844     if (jj_scan_token(40)) {
38845     jj_scanpos = xsp;
38846     if (jj_scan_token(41)) {
38847     jj_scanpos = xsp;
38848     if (jj_scan_token(46)) {
38849     jj_scanpos = xsp;
38850     if (jj_scan_token(47)) {
38851     jj_scanpos = xsp;
38852     if (jj_scan_token(48)) {
38853     jj_scanpos = xsp;
38854     if (jj_scan_token(49)) {
38855     jj_scanpos = xsp;
38856     if (jj_scan_token(50)) {
38857     jj_scanpos = xsp;
38858     if (jj_scan_token(51)) {
38859     jj_scanpos = xsp;
38860     if (jj_scan_token(52)) {
38861     jj_scanpos = xsp;
38862     if (jj_scan_token(56)) {
38863     jj_scanpos = xsp;
38864     if (jj_scan_token(58)) {
38865     jj_scanpos = xsp;
38866     if (jj_scan_token(59)) {
38867     jj_scanpos = xsp;
38868     if (jj_scan_token(60)) {
38869     jj_scanpos = xsp;
38870     if (jj_scan_token(61)) {
38871     jj_scanpos = xsp;
38872     if (jj_scan_token(63)) {
38873     jj_scanpos = xsp;
38874     if (jj_scan_token(66)) {
38875     jj_scanpos = xsp;
38876     if (jj_scan_token(67)) {
38877     jj_scanpos = xsp;
38878     if (jj_scan_token(68)) {
38879     jj_scanpos = xsp;
38880     if (jj_scan_token(69)) {
38881     jj_scanpos = xsp;
38882     if (jj_scan_token(71)) {
38883     jj_scanpos = xsp;
38884     if (jj_scan_token(77)) {
38885     jj_scanpos = xsp;
38886     if (jj_scan_token(78)) {
38887     jj_scanpos = xsp;
38888     if (jj_scan_token(79)) {
38889     jj_scanpos = xsp;
38890     if (jj_scan_token(83)) {
38891     jj_scanpos = xsp;
38892     if (jj_scan_token(85)) {
38893     jj_scanpos = xsp;
38894     if (jj_scan_token(88)) {
38895     jj_scanpos = xsp;
38896     if (jj_scan_token(90)) {
38897     jj_scanpos = xsp;
38898     if (jj_scan_token(91)) {
38899     jj_scanpos = xsp;
38900     if (jj_scan_token(92)) {
38901     jj_scanpos = xsp;
38902     if (jj_scan_token(93)) {
38903     jj_scanpos = xsp;
38904     if (jj_scan_token(94)) {
38905     jj_scanpos = xsp;
38906     if (jj_scan_token(97)) {
38907     jj_scanpos = xsp;
38908     if (jj_scan_token(98)) {
38909     jj_scanpos = xsp;
38910     if (jj_scan_token(99)) {
38911     jj_scanpos = xsp;
38912     if (jj_scan_token(102)) {
38913     jj_scanpos = xsp;
38914     if (jj_scan_token(103)) {
38915     jj_scanpos = xsp;
38916     if (jj_scan_token(108)) {
38917     jj_scanpos = xsp;
38918     if (jj_scan_token(110)) {
38919     jj_scanpos = xsp;
38920     if (jj_scan_token(111)) {
38921     jj_scanpos = xsp;
38922     if (jj_scan_token(112)) {
38923     jj_scanpos = xsp;
38924     if (jj_scan_token(118)) {
38925     jj_scanpos = xsp;
38926     if (jj_scan_token(120)) {
38927     jj_scanpos = xsp;
38928     if (jj_scan_token(121)) {
38929     jj_scanpos = xsp;
38930     if (jj_scan_token(122)) {
38931     jj_scanpos = xsp;
38932     if (jj_scan_token(124)) {
38933     jj_scanpos = xsp;
38934     if (jj_scan_token(127)) {
38935     jj_scanpos = xsp;
38936     if (jj_scan_token(128)) {
38937     jj_scanpos = xsp;
38938     if (jj_scan_token(131)) {
38939     jj_scanpos = xsp;
38940     if (jj_scan_token(135)) {
38941     jj_scanpos = xsp;
38942     if (jj_scan_token(137)) {
38943     jj_scanpos = xsp;
38944     if (jj_scan_token(139)) {
38945     jj_scanpos = xsp;
38946     if (jj_scan_token(144)) {
38947     jj_scanpos = xsp;
38948     if (jj_scan_token(146)) {
38949     jj_scanpos = xsp;
38950     if (jj_scan_token(147)) {
38951     jj_scanpos = xsp;
38952     if (jj_scan_token(148)) {
38953     jj_scanpos = xsp;
38954     if (jj_scan_token(150)) {
38955     jj_scanpos = xsp;
38956     if (jj_scan_token(152)) {
38957     jj_scanpos = xsp;
38958     if (jj_scan_token(156)) {
38959     jj_scanpos = xsp;
38960     if (jj_scan_token(158)) {
38961     jj_scanpos = xsp;
38962     if (jj_scan_token(159)) {
38963     jj_scanpos = xsp;
38964     if (jj_scan_token(160)) {
38965     jj_scanpos = xsp;
38966     if (jj_scan_token(161)) {
38967     jj_scanpos = xsp;
38968     if (jj_scan_token(167)) {
38969     jj_scanpos = xsp;
38970     if (jj_scan_token(171)) {
38971     jj_scanpos = xsp;
38972     if (jj_scan_token(172)) {
38973     jj_scanpos = xsp;
38974     if (jj_scan_token(175)) {
38975     jj_scanpos = xsp;
38976     if (jj_scan_token(178)) {
38977     jj_scanpos = xsp;
38978     if (jj_scan_token(181)) {
38979     jj_scanpos = xsp;
38980     if (jj_scan_token(183)) {
38981     jj_scanpos = xsp;
38982     if (jj_scan_token(184)) {
38983     jj_scanpos = xsp;
38984     if (jj_scan_token(185)) {
38985     jj_scanpos = xsp;
38986     if (jj_scan_token(187)) {
38987     jj_scanpos = xsp;
38988     if (jj_scan_token(192)) {
38989     jj_scanpos = xsp;
38990     if (jj_scan_token(194)) {
38991     jj_scanpos = xsp;
38992     if (jj_scan_token(195)) {
38993     jj_scanpos = xsp;
38994     if (jj_scan_token(197)) {
38995     jj_scanpos = xsp;
38996     if (jj_scan_token(188)) {
38997     jj_scanpos = xsp;
38998     if (jj_scan_token(189)) {
38999     jj_scanpos = xsp;
39000     if (jj_scan_token(190)) {
39001     jj_scanpos = xsp;
39002     if (jj_scan_token(191)) {
39003     jj_scanpos = xsp;
39004     if (jj_scan_token(201)) {
39005     jj_scanpos = xsp;
39006     if (jj_scan_token(202)) {
39007     jj_scanpos = xsp;
39008     if (jj_scan_token(203)) {
39009     jj_scanpos = xsp;
39010     if (jj_scan_token(204)) {
39011     jj_scanpos = xsp;
39012     if (jj_scan_token(207)) {
39013     jj_scanpos = xsp;
39014     if (jj_scan_token(212)) {
39015     jj_scanpos = xsp;
39016     if (jj_scan_token(215)) {
39017     jj_scanpos = xsp;
39018     if (jj_scan_token(216)) {
39019     jj_scanpos = xsp;
39020     if (jj_scan_token(217)) {
39021     jj_scanpos = xsp;
39022     if (jj_scan_token(220)) {
39023     jj_scanpos = xsp;
39024     if (jj_scan_token(222)) {
39025     jj_scanpos = xsp;
39026     if (jj_scan_token(221)) {
39027     jj_scanpos = xsp;
39028     if (jj_scan_token(224)) {
39029     jj_scanpos = xsp;
39030     if (jj_scan_token(225)) {
39031     jj_scanpos = xsp;
39032     if (jj_scan_token(227)) {
39033     jj_scanpos = xsp;
39034     if (jj_scan_token(246)) {
39035     jj_scanpos = xsp;
39036     if (jj_scan_token(250)) {
39037     jj_scanpos = xsp;
39038     if (jj_scan_token(252)) {
39039     jj_scanpos = xsp;
39040     if (jj_scan_token(255)) {
39041     jj_scanpos = xsp;
39042     if (jj_scan_token(256)) {
39043     jj_scanpos = xsp;
39044     if (jj_scan_token(258)) {
39045     jj_scanpos = xsp;
39046     if (jj_scan_token(259)) {
39047     jj_scanpos = xsp;
39048     if (jj_scan_token(260)) {
39049     jj_scanpos = xsp;
39050     if (jj_scan_token(261)) {
39051     jj_scanpos = xsp;
39052     if (jj_scan_token(263)) {
39053     jj_scanpos = xsp;
39054     if (jj_scan_token(267)) {
39055     jj_scanpos = xsp;
39056     if (jj_scan_token(268)) {
39057     jj_scanpos = xsp;
39058     if (jj_scan_token(269)) {
39059     jj_scanpos = xsp;
39060     if (jj_scan_token(271)) {
39061     jj_scanpos = xsp;
39062     if (jj_scan_token(273)) {
39063     jj_scanpos = xsp;
39064     if (jj_scan_token(280)) {
39065     jj_scanpos = xsp;
39066     if (jj_scan_token(282)) {
39067     jj_scanpos = xsp;
39068     if (jj_scan_token(284)) {
39069     jj_scanpos = xsp;
39070     if (jj_scan_token(285)) {
39071     jj_scanpos = xsp;
39072     if (jj_scan_token(297)) {
39073     jj_scanpos = xsp;
39074     if (jj_scan_token(298)) {
39075     jj_scanpos = xsp;
39076     if (jj_scan_token(299)) {
39077     jj_scanpos = xsp;
39078     if (jj_scan_token(303)) {
39079     jj_scanpos = xsp;
39080     if (jj_scan_token(305)) {
39081     jj_scanpos = xsp;
39082     if (jj_scan_token(308)) {
39083     jj_scanpos = xsp;
39084     if (jj_scan_token(318)) {
39085     jj_scanpos = xsp;
39086     if (jj_scan_token(292)) {
39087     jj_scanpos = xsp;
39088     if (jj_scan_token(432)) {
39089     jj_scanpos = xsp;
39090     if (jj_scan_token(429)) {
39091     jj_scanpos = xsp;
39092     if (jj_scan_token(430)) {
39093     jj_scanpos = xsp;
39094     if (jj_scan_token(431)) return true;
39095     }
39096     }
39097     }
39098     }
39099     }
39100     }
39101     }
39102     }
39103     }
39104     }
39105     }
39106     }
39107     }
39108     }
39109     }
39110     }
39111     }
39112     }
39113     }
39114     }
39115     }
39116     }
39117     }
39118     }
39119     }
39120     }
39121     }
39122     }
39123     }
39124     }
39125     }
39126     }
39127     }
39128     }
39129     }
39130     }
39131     }
39132     }
39133     }
39134     }
39135     }
39136     }
39137     }
39138     }
39139     }
39140     }
39141     }
39142     }
39143     }
39144     }
39145     }
39146     }
39147     }
39148     }
39149     }
39150     }
39151     }
39152     }
39153     }
39154     }
39155     }
39156     }
39157     }
39158     }
39159     }
39160     }
39161     }
39162     }
39163     }
39164     }
39165     }
39166     }
39167     }
39168     }
39169     }
39170     }
39171     }
39172     }
39173     }
39174     }
39175     }
39176     }
39177     }
39178     }
39179     }
39180     }
39181     }
39182     }
39183     }
39184     }
39185     }
39186     }
39187     }
39188     }
39189     }
39190     }
39191     }
39192     }
39193     }
39194     }
39195     }
39196     }
39197     }
39198     }
39199     }
39200     }
39201     }
39202     }
39203     }
39204     }
39205     }
39206     }
39207     }
39208     }
39209     }
39210     }
39211     }
39212     }
39213     }
39214     }
39215     }
39216     }
39217     }
39218     }
39219     }
39220     }
39221     }
39222     }
39223     }
39224     }
39225     }
39226     return false;
39227   }
39228 
39229   private boolean jj_3R_577() {
39230     if (jj_scan_token(IN)) return true;
39231     return false;
39232   }
39233 
39234   private boolean jj_3R_608() {
39235     if (jj_scan_token(15)) return true;
39236     return false;
39237   }
39238 
39239   private boolean jj_3R_576() {
39240     if (jj_scan_token(NOT)) return true;
39241     return false;
39242   }
39243 
39244   private boolean jj_3R_575() {
39245     if (jj_scan_token(10)) return true;
39246     return false;
39247   }
39248 
39249   private boolean jj_3R_574() {
39250     if (jj_scan_token(15)) return true;
39251     return false;
39252   }
39253 
39254   private boolean jj_3R_539() {
39255     Token xsp;
39256     xsp = jj_scanpos;
39257     if (jj_3R_576()) jj_scanpos = xsp;
39258     xsp = jj_scanpos;
39259     if (jj_3R_577()) {
39260     jj_scanpos = xsp;
39261     if (jj_3R_578()) {
39262     jj_scanpos = xsp;
39263     if (jj_3R_579()) {
39264     jj_scanpos = xsp;
39265     if (jj_3R_580()) {
39266     jj_scanpos = xsp;
39267     if (jj_3R_581()) return true;
39268     }
39269     }
39270     }
39271     }
39272     return false;
39273   }
39274 
39275   private boolean jj_3R_573() {
39276     if (jj_scan_token(14)) return true;
39277     Token xsp;
39278     xsp = jj_scanpos;
39279     if (jj_3R_608()) jj_scanpos = xsp;
39280     return false;
39281   }
39282 
39283   private boolean jj_3R_321() {
39284     if (jj_3R_350()) return true;
39285     return false;
39286   }
39287 
39288   private boolean jj_3R_320() {
39289     if (jj_3R_173()) return true;
39290     return false;
39291   }
39292 
39293   private boolean jj_3R_116() {
39294     if (jj_3R_190()) return true;
39295     return false;
39296   }
39297 
39298   private boolean jj_3R_538() {
39299     Token xsp;
39300     xsp = jj_scanpos;
39301     if (jj_3R_573()) {
39302     jj_scanpos = xsp;
39303     if (jj_3R_574()) return true;
39304     }
39305     xsp = jj_scanpos;
39306     if (jj_3R_575()) jj_scanpos = xsp;
39307     return false;
39308   }
39309 
39310   private boolean jj_3_14() {
39311     Token xsp;
39312     while (true) {
39313       xsp = jj_scanpos;
39314       if (jj_3R_116()) { jj_scanpos = xsp; break; }
39315     }
39316     xsp = jj_scanpos;
39317     if (jj_3R_117()) jj_scanpos = xsp;
39318     if (jj_scan_token(BEGIN)) return true;
39319     return false;
39320   }
39321 
39322   private boolean jj_3R_319() {
39323     if (jj_scan_token(DECLARE)) return true;
39324     if (jj_3R_191()) return true;
39325     return false;
39326   }
39327 
39328   private boolean jj_3R_508() {
39329     Token xsp;
39330     xsp = jj_scanpos;
39331     if (jj_3R_538()) {
39332     jj_scanpos = xsp;
39333     if (jj_3R_539()) {
39334     jj_scanpos = xsp;
39335     if (jj_3R_540()) return true;
39336     }
39337     }
39338     if (jj_3R_507()) return true;
39339     xsp = jj_scanpos;
39340     if (jj_3R_541()) jj_scanpos = xsp;
39341     return false;
39342   }
39343 
39344   private boolean jj_3R_271() {
39345     Token xsp;
39346     xsp = jj_scanpos;
39347     if (jj_3R_319()) jj_scanpos = xsp;
39348     if (jj_scan_token(BEGIN)) return true;
39349     while (true) {
39350       xsp = jj_scanpos;
39351       if (jj_3R_320()) { jj_scanpos = xsp; break; }
39352     }
39353     xsp = jj_scanpos;
39354     if (jj_3R_321()) jj_scanpos = xsp;
39355     if (jj_scan_token(END)) return true;
39356     xsp = jj_scanpos;
39357     if (jj_scan_token(420)) jj_scanpos = xsp;
39358     return false;
39359   }
39360 
39361   private boolean jj_3R_481() {
39362     if (jj_3R_507()) return true;
39363     Token xsp;
39364     while (true) {
39365       xsp = jj_scanpos;
39366       if (jj_3R_508()) { jj_scanpos = xsp; break; }
39367     }
39368     return false;
39369   }
39370 
39371   private boolean jj_3R_185() {
39372     Token xsp;
39373     while (true) {
39374       xsp = jj_scanpos;
39375       if (jj_3R_270()) { jj_scanpos = xsp; break; }
39376     }
39377     if (jj_3R_271()) return true;
39378     if (jj_scan_token(4)) return true;
39379     return false;
39380   }
39381 
39382   private boolean jj_3R_511() {
39383     if (jj_scan_token(IS)) return true;
39384     return false;
39385   }
39386 
39387   private boolean jj_3R_510() {
39388     if (jj_scan_token(13)) return true;
39389     if (jj_scan_token(10)) return true;
39390     return false;
39391   }
39392 
39393   private boolean jj_3R_509() {
39394     if (jj_scan_token(10)) return true;
39395     return false;
39396   }
39397 
39398   private boolean jj_3R_113() {
39399     Token xsp;
39400     xsp = jj_scanpos;
39401     if (jj_3R_185()) {
39402     jj_scanpos = xsp;
39403     if (jj_3_15()) return true;
39404     }
39405     return false;
39406   }
39407 
39408   private boolean jj_3R_482() {
39409     Token xsp;
39410     xsp = jj_scanpos;
39411     if (jj_3R_509()) {
39412     jj_scanpos = xsp;
39413     if (jj_3R_510()) {
39414     jj_scanpos = xsp;
39415     if (jj_3R_511()) return true;
39416     }
39417     }
39418     if (jj_3R_481()) return true;
39419     return false;
39420   }
39421 
39422   private boolean jj_3R_436() {
39423     if (jj_3R_481()) return true;
39424     Token xsp;
39425     while (true) {
39426       xsp = jj_scanpos;
39427       if (jj_3R_482()) { jj_scanpos = xsp; break; }
39428     }
39429     return false;
39430   }
39431 
39432   private boolean jj_3R_437() {
39433     if (jj_scan_token(AND)) return true;
39434     if (jj_3R_436()) return true;
39435     return false;
39436   }
39437 
39438   private boolean jj_3R_394() {
39439     if (jj_3R_436()) return true;
39440     Token xsp;
39441     while (true) {
39442       xsp = jj_scanpos;
39443       if (jj_3R_437()) { jj_scanpos = xsp; break; }
39444     }
39445     return false;
39446   }
39447 
39448   private boolean jj_3R_395() {
39449     if (jj_scan_token(OR)) return true;
39450     if (jj_3R_394()) return true;
39451     return false;
39452   }
39453 
39454   private boolean jj_3R_188() {
39455     if (jj_scan_token(3)) return true;
39456     if (jj_scan_token(ATTACH)) return true;
39457     return false;
39458   }
39459 
39460   private boolean jj_3R_343() {
39461     if (jj_3R_394()) return true;
39462     Token xsp;
39463     while (true) {
39464       xsp = jj_scanpos;
39465       if (jj_3R_395()) { jj_scanpos = xsp; break; }
39466     }
39467     return false;
39468   }
39469 
39470   private boolean jj_3R_236() {
39471     if (jj_scan_token(3)) return true;
39472     if (jj_3R_233()) return true;
39473     return false;
39474   }
39475 
39476   private boolean jj_3R_234() {
39477     if (jj_scan_token(AT)) return true;
39478     if (jj_scan_token(TIME)) return true;
39479     if (jj_scan_token(ZONE)) return true;
39480     if (jj_3R_133()) return true;
39481     return false;
39482   }
39483 
39484   private boolean jj_3R_139() {
39485     Token xsp;
39486     xsp = jj_scanpos;
39487     if (jj_scan_token(390)) {
39488     jj_scanpos = xsp;
39489     if (jj_scan_token(391)) return true;
39490     }
39491     if (jj_scan_token(5)) return true;
39492     if (jj_3R_233()) return true;
39493     xsp = jj_scanpos;
39494     if (jj_3R_234()) jj_scanpos = xsp;
39495     if (jj_scan_token(AS)) return true;
39496     if (jj_3R_235()) return true;
39497     if (jj_scan_token(7)) return true;
39498     while (true) {
39499       xsp = jj_scanpos;
39500       if (jj_3R_236()) { jj_scanpos = xsp; break; }
39501     }
39502     return false;
39503   }
39504 
39505   private boolean jj_3R_228() {
39506     if (jj_3R_229()) return true;
39507     return false;
39508   }
39509 
39510   private boolean jj_3R_115() {
39511     Token xsp;
39512     xsp = jj_scanpos;
39513     if (jj_scan_token(2)) {
39514     jj_scanpos = xsp;
39515     if (jj_scan_token(377)) {
39516     jj_scanpos = xsp;
39517     if (jj_scan_token(74)) {
39518     jj_scanpos = xsp;
39519     if (jj_scan_token(78)) {
39520     jj_scanpos = xsp;
39521     if (jj_scan_token(379)) {
39522     jj_scanpos = xsp;
39523     if (jj_scan_token(380)) {
39524     jj_scanpos = xsp;
39525     if (jj_scan_token(381)) {
39526     jj_scanpos = xsp;
39527     if (jj_scan_token(111)) {
39528     jj_scanpos = xsp;
39529     if (jj_scan_token(113)) {
39530     jj_scanpos = xsp;
39531     if (jj_scan_token(382)) {
39532     jj_scanpos = xsp;
39533     if (jj_scan_token(383)) {
39534     jj_scanpos = xsp;
39535     if (jj_scan_token(221)) {
39536     jj_scanpos = xsp;
39537     if (jj_scan_token(384)) {
39538     jj_scanpos = xsp;
39539     if (jj_scan_token(385)) {
39540     jj_scanpos = xsp;
39541     if (jj_scan_token(253)) {
39542     jj_scanpos = xsp;
39543     if (jj_scan_token(294)) {
39544     jj_scanpos = xsp;
39545     if (jj_scan_token(295)) {
39546     jj_scanpos = xsp;
39547     if (jj_scan_token(261)) {
39548     jj_scanpos = xsp;
39549     if (jj_scan_token(386)) {
39550     jj_scanpos = xsp;
39551     if (jj_scan_token(387)) {
39552     jj_scanpos = xsp;
39553     if (jj_scan_token(388)) {
39554     jj_scanpos = xsp;
39555     if (jj_scan_token(75)) {
39556     jj_scanpos = xsp;
39557     if (jj_scan_token(129)) {
39558     jj_scanpos = xsp;
39559     if (jj_scan_token(240)) {
39560     jj_scanpos = xsp;
39561     if (jj_scan_token(99)) {
39562     jj_scanpos = xsp;
39563     if (jj_scan_token(420)) {
39564     jj_scanpos = xsp;
39565     if (jj_3R_188()) return true;
39566     }
39567     }
39568     }
39569     }
39570     }
39571     }
39572     }
39573     }
39574     }
39575     }
39576     }
39577     }
39578     }
39579     }
39580     }
39581     }
39582     }
39583     }
39584     }
39585     }
39586     }
39587     }
39588     }
39589     }
39590     }
39591     }
39592     if (jj_3R_189()) return true;
39593     return false;
39594   }
39595 
39596   private boolean jj_3R_227() {
39597     Token xsp;
39598     xsp = jj_scanpos;
39599     if (jj_scan_token(399)) {
39600     jj_scanpos = xsp;
39601     if (jj_scan_token(400)) {
39602     jj_scanpos = xsp;
39603     if (jj_scan_token(395)) return true;
39604     }
39605     }
39606     return false;
39607   }
39608 
39609   private boolean jj_3R_114() {
39610     if (jj_3R_186()) return true;
39611     if (jj_3R_187()) return true;
39612     return false;
39613   }
39614 
39615   private boolean jj_3R_137() {
39616     if (jj_scan_token(TRIM)) return true;
39617     if (jj_scan_token(5)) return true;
39618     Token xsp;
39619     xsp = jj_scanpos;
39620     if (jj_3R_227()) jj_scanpos = xsp;
39621     xsp = jj_scanpos;
39622     if (jj_3R_228()) jj_scanpos = xsp;
39623     if (jj_scan_token(FROM)) return true;
39624     if (jj_3R_229()) return true;
39625     if (jj_scan_token(7)) return true;
39626     return false;
39627   }
39628 
39629   private boolean jj_3_13() {
39630     if (jj_3R_115()) return true;
39631     return false;
39632   }
39633 
39634   private boolean jj_3_12() {
39635     if (jj_3R_114()) return true;
39636     return false;
39637   }
39638 
39639   private boolean jj_3_11() {
39640     if (jj_3R_113()) return true;
39641     return false;
39642   }
39643 
39644   private boolean jj_3_10() {
39645     if (jj_3R_112()) return true;
39646     return false;
39647   }
39648 
39649   private boolean jj_3_9() {
39650     if (jj_3R_111()) return true;
39651     return false;
39652   }
39653 
39654   private boolean jj_3_8() {
39655     if (jj_3R_110()) return true;
39656     return false;
39657   }
39658 
39659   private boolean jj_3_7() {
39660     if (jj_3R_109()) return true;
39661     return false;
39662   }
39663 
39664   private boolean jj_3_6() {
39665     if (jj_3R_108()) return true;
39666     return false;
39667   }
39668 
39669   private boolean jj_3_5() {
39670     if (jj_3R_107()) return true;
39671     return false;
39672   }
39673 
39674   private boolean jj_3_4() {
39675     if (jj_3R_106()) return true;
39676     return false;
39677   }
39678 
39679   private boolean jj_3_3() {
39680     if (jj_3R_105()) return true;
39681     return false;
39682   }
39683 
39684   private boolean jj_3_2() {
39685     if (jj_3R_104()) return true;
39686     return false;
39687   }
39688 
39689   private boolean jj_3_1() {
39690     if (jj_3R_103()) return true;
39691     return false;
39692   }
39693 
39694   private boolean jj_3R_232() {
39695     if (jj_scan_token(ELSE)) return true;
39696     if (jj_3R_233()) return true;
39697     return false;
39698   }
39699 
39700   private boolean jj_3R_231() {
39701     if (jj_scan_token(WHEN)) return true;
39702     if (jj_3R_233()) return true;
39703     if (jj_scan_token(THEN)) return true;
39704     if (jj_3R_233()) return true;
39705     return false;
39706   }
39707 
39708   private boolean jj_3R_230() {
39709     if (jj_3R_233()) return true;
39710     return false;
39711   }
39712 
39713   private boolean jj_3R_138() {
39714     if (jj_scan_token(CASE)) return true;
39715     Token xsp;
39716     xsp = jj_scanpos;
39717     if (jj_3R_230()) jj_scanpos = xsp;
39718     if (jj_3R_231()) return true;
39719     while (true) {
39720       xsp = jj_scanpos;
39721       if (jj_3R_231()) { jj_scanpos = xsp; break; }
39722     }
39723     xsp = jj_scanpos;
39724     if (jj_3R_232()) jj_scanpos = xsp;
39725     if (jj_scan_token(END)) return true;
39726     return false;
39727   }
39728 
39729   private boolean jj_3R_342() {
39730     if (jj_3R_133()) return true;
39731     if (jj_scan_token(9)) return true;
39732     if (jj_scan_token(10)) return true;
39733     if (jj_3R_233()) return true;
39734     return false;
39735   }
39736 
39737   private boolean jj_3R_397() {
39738     if (jj_scan_token(CC_ELSE)) return true;
39739     if (jj_3R_233()) return true;
39740     return false;
39741   }
39742 
39743   private boolean jj_3R_396() {
39744     if (jj_scan_token(CC_ELSIF)) return true;
39745     if (jj_3R_343()) return true;
39746     if (jj_scan_token(CC_THEN)) return true;
39747     if (jj_3R_233()) return true;
39748     return false;
39749   }
39750 
39751   private boolean jj_3R_344() {
39752     if (jj_scan_token(CC_IF)) return true;
39753     if (jj_3R_343()) return true;
39754     if (jj_scan_token(CC_THEN)) return true;
39755     if (jj_3R_233()) return true;
39756     Token xsp;
39757     while (true) {
39758       xsp = jj_scanpos;
39759       if (jj_3R_396()) { jj_scanpos = xsp; break; }
39760     }
39761     while (true) {
39762       xsp = jj_scanpos;
39763       if (jj_3R_397()) { jj_scanpos = xsp; break; }
39764     }
39765     if (jj_scan_token(CC_END)) return true;
39766     return false;
39767   }
39768 
39769   private boolean jj_3_45() {
39770     if (jj_3R_133()) return true;
39771     if (jj_scan_token(9)) return true;
39772     if (jj_scan_token(10)) return true;
39773     return false;
39774   }
39775 
39776   private boolean jj_3R_109() {
39777     if (jj_scan_token(ALTER)) return true;
39778     if (jj_scan_token(TRIGGER)) return true;
39779     if (jj_3R_179()) return true;
39780     if (jj_scan_token(4)) return true;
39781     return false;
39782   }
39783 
39784   private boolean jj_3R_302() {
39785     if (jj_3R_344()) return true;
39786     return false;
39787   }
39788 
39789   private boolean jj_3R_301() {
39790     if (jj_3R_343()) return true;
39791     return false;
39792   }
39793 
39794   private boolean jj_3R_300() {
39795     if (jj_3R_342()) return true;
39796     return false;
39797   }
39798 
39799   private boolean jj_3R_318() {
39800     if (jj_3R_377()) return true;
39801     return false;
39802   }
39803 
39804   private boolean jj_3R_233() {
39805     Token xsp;
39806     xsp = jj_scanpos;
39807     if (jj_3R_300()) {
39808     jj_scanpos = xsp;
39809     if (jj_3R_301()) {
39810     jj_scanpos = xsp;
39811     if (jj_3R_302()) return true;
39812     }
39813     }
39814     return false;
39815   }
39816 
39817   private boolean jj_3R_317() {
39818     if (jj_3R_186()) return true;
39819     return false;
39820   }
39821 
39822   private boolean jj_3R_267() {
39823     Token xsp;
39824     xsp = jj_scanpos;
39825     if (jj_3R_317()) {
39826     jj_scanpos = xsp;
39827     if (jj_3R_318()) return true;
39828     }
39829     return false;
39830   }
39831 
39832   private boolean jj_3R_377() {
39833     Token xsp;
39834     xsp = jj_scanpos;
39835     if (jj_scan_token(361)) {
39836     jj_scanpos = xsp;
39837     if (jj_scan_token(360)) {
39838     jj_scanpos = xsp;
39839     if (jj_scan_token(355)) {
39840     jj_scanpos = xsp;
39841     if (jj_scan_token(354)) {
39842     jj_scanpos = xsp;
39843     if (jj_scan_token(359)) {
39844     jj_scanpos = xsp;
39845     if (jj_scan_token(364)) return true;
39846     }
39847     }
39848     }
39849     }
39850     }
39851     return false;
39852   }
39853 
39854   private boolean jj_3R_423() {
39855     if (jj_3R_198()) return true;
39856     return false;
39857   }
39858 
39859   private boolean jj_3R_122() {
39860     if (jj_3R_198()) return true;
39861     return false;
39862   }
39863 
39864   private boolean jj_3R_273() {
39865     if (jj_scan_token(DISASSOCIATE)) return true;
39866     if (jj_scan_token(STATISTICS)) return true;
39867     return false;
39868   }
39869 
39870   private boolean jj_3_84() {
39871     if (jj_3R_124()) return true;
39872     if (jj_scan_token(3)) return true;
39873     return false;
39874   }
39875 
39876   private boolean jj_3R_501() {
39877     if (jj_scan_token(IS)) return true;
39878     Token xsp;
39879     while (true) {
39880       xsp = jj_scanpos;
39881       if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
39882     }
39883     if (jj_3R_404()) return true;
39884     return false;
39885   }
39886 
39887   private boolean jj_3R_272() {
39888     if (jj_scan_token(ASSOCIATE)) return true;
39889     if (jj_scan_token(STATISTICS)) return true;
39890     return false;
39891   }
39892 
39893   private boolean jj_3R_500() {
39894     if (jj_scan_token(RETURN)) return true;
39895     if (jj_3R_235()) return true;
39896     return false;
39897   }
39898 
39899   private boolean jj_3R_499() {
39900     if (jj_3R_385()) return true;
39901     return false;
39902   }
39903 
39904   private boolean jj_3R_186() {
39905     Token xsp;
39906     xsp = jj_scanpos;
39907     if (jj_scan_token(47)) {
39908     jj_scanpos = xsp;
39909     if (jj_scan_token(344)) {
39910     jj_scanpos = xsp;
39911     if (jj_3R_272()) {
39912     jj_scanpos = xsp;
39913     if (jj_scan_token(346)) {
39914     jj_scanpos = xsp;
39915     if (jj_scan_token(75)) {
39916     jj_scanpos = xsp;
39917     if (jj_scan_token(83)) {
39918     jj_scanpos = xsp;
39919     if (jj_3R_273()) {
39920     jj_scanpos = xsp;
39921     if (jj_scan_token(99)) {
39922     jj_scanpos = xsp;
39923     if (jj_scan_token(129)) {
39924     jj_scanpos = xsp;
39925     if (jj_scan_token(357)) {
39926     jj_scanpos = xsp;
39927     if (jj_scan_token(233)) {
39928     jj_scanpos = xsp;
39929     if (jj_scan_token(240)) {
39930     jj_scanpos = xsp;
39931     if (jj_scan_token(365)) {
39932     jj_scanpos = xsp;
39933     if (jj_scan_token(350)) return true;
39934     }
39935     }
39936     }
39937     }
39938     }
39939     }
39940     }
39941     }
39942     }
39943     }
39944     }
39945     }
39946     }
39947     return false;
39948   }
39949 
39950   private boolean jj_3R_198() {
39951     if (jj_scan_token(CURSOR)) return true;
39952     if (jj_3R_124()) return true;
39953     Token xsp;
39954     xsp = jj_scanpos;
39955     if (jj_3R_499()) jj_scanpos = xsp;
39956     xsp = jj_scanpos;
39957     if (jj_3R_500()) jj_scanpos = xsp;
39958     xsp = jj_scanpos;
39959     if (jj_3R_501()) jj_scanpos = xsp;
39960     if (jj_scan_token(4)) return true;
39961     return false;
39962   }
39963 
39964   private boolean jj_3R_562() {
39965     if (jj_3R_182()) return true;
39966     return false;
39967   }
39968 
39969   private boolean jj_3R_632() {
39970     if (jj_3R_182()) return true;
39971     return false;
39972   }
39973 
39974   private boolean jj_3_79() {
39975     if (jj_3R_124()) return true;
39976     if (jj_scan_token(3)) return true;
39977     return false;
39978   }
39979 
39980   private boolean jj_3_83() {
39981     if (jj_3R_122()) return true;
39982     return false;
39983   }
39984 
39985   private boolean jj_3R_269() {
39986     if (jj_3R_267()) return true;
39987     return false;
39988   }
39989 
39990   private boolean jj_3_82() {
39991     if (jj_3R_121()) return true;
39992     return false;
39993   }
39994 
39995   private boolean jj_3R_561() {
39996     if (jj_3R_182()) return true;
39997     return false;
39998   }
39999 
40000   private boolean jj_3_81() {
40001     if (jj_3R_152()) return true;
40002     return false;
40003   }
40004 
40005   private boolean jj_3_80() {
40006     if (jj_3R_119()) return true;
40007     return false;
40008   }
40009 
40010   private boolean jj_3R_424() {
40011     if (jj_scan_token(IDENTIFIER)) return true;
40012     return false;
40013   }
40014 
40015   private boolean jj_3R_176() {
40016     if (jj_3R_267()) return true;
40017     return false;
40018   }
40019 
40020   private boolean jj_3R_151() {
40021     if (jj_scan_token(6)) return true;
40022     if (jj_3R_124()) return true;
40023     return false;
40024   }
40025 
40026   private boolean jj_3R_150() {
40027     if (jj_scan_token(6)) return true;
40028     if (jj_3R_124()) return true;
40029     return false;
40030   }
40031 
40032   private boolean jj_3R_629() {
40033     if (jj_scan_token(3)) return true;
40034     Token xsp;
40035     xsp = jj_scanpos;
40036     if (jj_scan_token(420)) {
40037     jj_scanpos = xsp;
40038     if (jj_scan_token(428)) {
40039     jj_scanpos = xsp;
40040     if (jj_3R_632()) return true;
40041     }
40042     }
40043     return false;
40044   }
40045 
40046   private boolean jj_3_75() {
40047     if (jj_3R_124()) return true;
40048     if (jj_scan_token(3)) return true;
40049     return false;
40050   }
40051 
40052   private boolean jj_3R_598() {
40053     if (jj_scan_token(9)) return true;
40054     if (jj_scan_token(10)) return true;
40055     return false;
40056   }
40057 
40058   private boolean jj_3R_289() {
40059     if (jj_scan_token(PARAMETERS)) return true;
40060     if (jj_3R_563()) return true;
40061     return false;
40062   }
40063 
40064   private boolean jj_3_78() {
40065     if (jj_3R_124()) return true;
40066     if (jj_scan_token(3)) return true;
40067     return false;
40068   }
40069 
40070   private boolean jj_3R_565() {
40071     Token xsp;
40072     xsp = jj_scanpos;
40073     if (jj_3R_598()) {
40074     jj_scanpos = xsp;
40075     if (jj_scan_token(92)) return true;
40076     }
40077     if (jj_3R_233()) return true;
40078     return false;
40079   }
40080 
40081   private boolean jj_3R_525() {
40082     if (jj_scan_token(5)) return true;
40083     if (jj_3R_127()) return true;
40084     if (jj_scan_token(7)) return true;
40085     return false;
40086   }
40087 
40088   private boolean jj_3_74() {
40089     if (jj_scan_token(OF)) return true;
40090     if (jj_3R_124()) return true;
40091     Token xsp;
40092     while (true) {
40093       xsp = jj_scanpos;
40094       if (jj_3R_151()) { jj_scanpos = xsp; break; }
40095     }
40096     return false;
40097   }
40098 
40099   private boolean jj_3R_288() {
40100     if (jj_scan_token(WITH)) return true;
40101     if (jj_scan_token(CONTEXT)) return true;
40102     return false;
40103   }
40104 
40105   /** Generated Token Manager. */
40106   public PLSQLParserTokenManager token_source;
40107   SimpleCharStream jj_input_stream;
40108   /** Current token. */
40109   public Token token;
40110   /** Next token. */
40111   public Token jj_nt;
40112   private Token jj_scanpos, jj_lastpos;
40113   private int jj_la;
40114   private int jj_gen;
40115   final private int[] jj_la1 = new int[458];
40116   static private int[] jj_la1_0;
40117   static private int[] jj_la1_1;
40118   static private int[] jj_la1_2;
40119   static private int[] jj_la1_3;
40120   static private int[] jj_la1_4;
40121   static private int[] jj_la1_5;
40122   static private int[] jj_la1_6;
40123   static private int[] jj_la1_7;
40124   static private int[] jj_la1_8;
40125   static private int[] jj_la1_9;
40126   static private int[] jj_la1_10;
40127   static private int[] jj_la1_11;
40128   static private int[] jj_la1_12;
40129   static private int[] jj_la1_13;
40130   static {
40131       jj_la1_init_0();
40132       jj_la1_init_1();
40133       jj_la1_init_2();
40134       jj_la1_init_3();
40135       jj_la1_init_4();
40136       jj_la1_init_5();
40137       jj_la1_init_6();
40138       jj_la1_init_7();
40139       jj_la1_init_8();
40140       jj_la1_init_9();
40141       jj_la1_init_10();
40142       jj_la1_init_11();
40143       jj_la1_init_12();
40144       jj_la1_init_13();
40145    }
40146    private static void jj_la1_init_0() {
40147       jj_la1_0 = new int[] {0x20000c,0x0,0x0,0x2,0xc,0x200000,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x8,0x0,0x8,0x0,0x0,0x40,0x0,0x0,0x8,0x40,0x8,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x100,0x200,0x200,0x0,0x20,0x0,0x20,0x0,0x40,0x0,0x0,0x0,0x200,0x200,0x4,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x230020,0x0,0x0,0x10,0x30020,0x230020,0x200000,0x30020,0x0,0x0,0x0,0x230020,0x230020,0x230020,0x230020,0x0,0x0,0x1000,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x0,0x0,0x1000,0x30020,0x0,0x30020,0x0,0x0,0x0,0x0,0x0,0x30020,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x20,0x20,0x0,0x0,0x0,0x40,0x40,0x0,0x20,0x0,0x0,0x0,0x40,0x20,0x0,0x0,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x20,0x0,0x30020,0x0,0x0,0x30020,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x0,0x8,0x0,0x0,0x2400,0x2400,0xc000,0x8000,0xc000,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000,0x0,0x0,0x70000,0x70000,0x40000,0x180002,0x180002,0x30000,0x30020,0x20,0x0,0x0,0x0,0x40,0x0,0x20,0x20,0x20,0x40,0x0,0x0,0x20,0x30020,0x0,0x2c,0x0,0x0,0x0,0x808,0x8,0x30020,0x40,0x800000,0x0,0x0,0x0,0x40,0x30000,0x30000,0x40,0x0,0x0,0x40,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x20,0x12,0x0,0x0,0x12,0x0,0x12,0x0,0x0,0x0,0x0,0x0,0x12,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x12,0x0,0x12,0x12,0x40,0x40,0x0,0x20,0x40,0x80,0x0,0x0,0x20,0x40,0x80,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x30000,0x30000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
40148    }
40149    private static void jj_la1_init_1() {
40150       jj_la1_1 = new int[] {0x2008000,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x30,0x800000,0x80000,0xfdfffff8,0x80000,0x0,0x0,0x0,0x0,0x0,0x80000,0x52e43c38,0x0,0x2000000,0xfdfffff8,0x80000,0x0,0x0,0xfdfffff8,0xfdfffff8,0xfdfffff8,0x0,0xfdfffff8,0xfdfffff8,0x0,0xfdfffff8,0xfdfffff8,0x0,0x0,0x0,0x0,0x800000,0x30,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x2000,0x80000,0x0,0x52e43c38,0x0,0xfdfffff8,0xfffffff8,0x80000,0x882000,0x0,0x0,0x78e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x0,0x50e43c38,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x52e43c38,0x52e43c38,0x0,0x0,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x50e43c38,0x50e43c38,0x0,0x50e43c38,0x0,0x50e43c38,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x78e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x200000,0x0,0x0,0x10000,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x4000,0x4000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x50e43c38,0x0,0x0,0x50e43c38,0x0,0x50e43c38,0x0,0x200000,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x80000,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x50e43ff8,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x52e43c38,0x0,0xfdfffff8,0xfffffff8,0x80000,0x0,0x0,0x0,0x0,0x0,0x30,0x800000,0x80000,0x80000,0x0,0x0,0x0,0x80000,0x0,0x80000,0x0,0xfdfffff8,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x8000,0x0,0x0,0x1000,0x0,0x1000,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x400000,0x400000,0x1000,0x30,0x800000,0x80000,0xfdfffff8,0x0,0xfdfffff8,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x0,0x0,0x8000,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x52e43c38,0x0,0x0,0xfdfffff8,0x0,0x0,0xfdfffff8,0x0,0x8000,0x0,0x8000,0xfdfffff8,0x8000,0x0,0x8000,0x841bc000,0x40e03c30,0xfdfffff8,0x50e43c38,0x79e43ff8,0x28840000,0x0,};
40151    }
40152    private static void jj_la1_init_2() {
40153       jj_la1_2 = new int[] {0x24085c00,0x20001000,0x20001000,0x0,0x4c00,0x0,0x4000000,0x27d71f47,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x27d71f47,0x0,0x0,0x7fffffff,0x0,0x0,0x490000,0x7fffffff,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x80000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x80,0x7fffffff,0x0,0x80,0x80,0x0,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0,0x27d71f47,0x0,0x7fffffff,0x7fffffff,0x0,0x80000000,0x0,0x0,0xbd71f5b,0x10000000,0x10000000,0x90000,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x2d71f43,0x0,0x0,0x0,0x0,0x8,0x1,0x8,0x0,0x9000018,0x0,0x0,0x8,0x1,0x0,0x0,0x1000000,0x0,0x2000000,0x2000000,0x0,0x2000000,0x0,0x0,0x0,0x27d71f47,0x27d71f47,0x0,0x20001000,0x0,0x7d71f47,0x27d71f47,0x0,0x3d71f47,0x0,0x0,0x0,0x27d71f47,0x27d71f47,0x27d71f47,0x27d71f47,0x0,0x0,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x3d71f47,0x2d71f43,0x0,0x2d71f43,0x0,0x2d71f43,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbd71f5b,0x0,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x3d71f47,0x3d71f47,0x0,0x1000000,0x2d71f43,0x0,0x3d71f47,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x2d71f43,0x0,0x0,0x0,0x80,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2d71f43,0x2d75f43,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x27d71f47,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x7fffffff,0x0,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x0,0x0,0x10000,0x10000,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x40000,0x0,0x40000,0x0,0x0,0x2,0x2,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x20000000,0x0,0x20080800,0x0,0x20000000,0x0,0x20080800,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x27d71f47,0x0,0x0,0x7fffffff,0x0,0x480000,0x7fffffff,0x0,0x80800,0x0,0x80800,0x7fffffff,0x80800,0x0,0x80800,0x790860a8,0x2d71f43,0x7fffffff,0x2d71f43,0x2bf79f5b,0x9200008,0x0,};
40154    }
40155    private static void jj_la1_init_3() {
40156       jj_la1_3 = new int[] {0x20028008,0x0,0x0,0x0,0x28008,0x0,0x0,0xeefead31,0x1000,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0xeefead31,0x1000,0x0,0xfffffdff,0x0,0x0,0x20800000,0xfffffdff,0xfffffdff,0xfffffdff,0x0,0xfffffdff,0xfffffdff,0x0,0xfffffdff,0xfffffdff,0x0,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x1000,0xfffffdff,0xfffffdff,0x0,0x0,0x0,0x0,0x69be2d31,0x0,0x0,0x20800000,0x0,0x0,0x0,0x20000000,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0xeefead31,0x0,0x8000,0x0,0xeefead31,0xeefead31,0x0,0x68be2d31,0x0,0x40,0x0,0xeefead31,0xeefead31,0xeefead31,0xeefead31,0x0,0x0,0x0,0xeefead31,0x0,0xeefead31,0x0,0xeefead31,0x80,0x40,0x0,0x0,0x68be2d31,0x0,0x68be2d31,0x68be2d31,0x0,0x68be2d31,0x0,0x68be2d31,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x0,0xeefead31,0x0,0xeefead31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x69be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x68be2d31,0x0,0x40,0x0,0x400,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x800,0x2,0x2,0x10000000,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x68be2d31,0x0,0x200000,0x68be2d31,0x0,0x68be2d31,0x0,0x0,0x200000,0x200000,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x20000000,0x0,0x20000000,0x20000000,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x1000,0xfffffdff,0xfffffdff,0x0,0x0,0x10,0x10,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0xfffffdff,0x0,0x800000,0x0,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x800020,0x800020,0x0,0x0,0x0,0x800000,0x800000,0x8,0x0,0x0,0x0,0xfffffdff,0x0,0xfffffdff,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x8000000,0x8002000,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x10,0x10,0x0,0x2000000,0x0,0x0,0x8,0x0,0x0,0x0,0x8,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x101,0x101,0x0,0x0,0x0,0x0,0xeefead31,0x0,0x0,0xfffffdff,0x0,0x20000000,0xfffffdff,0x0,0x8,0x0,0x8,0xfffffdff,0x8,0x0,0x8,0x1301404a,0x68be2d31,0xfffffdff,0x68be2d31,0x6dbfadb5,0x1000000,0x0,};
40157    }
40158    private static void jj_la1_init_4() {
40159       jj_la1_4 = new int[] {0x80010002,0x80010000,0x80010000,0x0,0x2,0x0,0x0,0xaea3d1b4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0xffffdbbd,0x1000000,0x0,0x0,0x0,0x0,0x0,0x1000000,0xaea3d1b4,0x0,0x0,0xffffdbbd,0x1000000,0x0,0x20000,0xffffdbbd,0xffffdbbd,0xffffdbbd,0x0,0xffffdbbd,0xffffdbbd,0x0,0xffffdbbd,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0xaea3d1b4,0x0,0xffffdbbd,0xffffdbbd,0x1000000,0x1000000,0x200,0x200,0x2ea6d134,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x20,0x20,0x0,0x20,0x0,0x0,0x0,0xaea3d1b4,0xaea3d1b4,0x0,0x80010000,0x0,0x2ea2d1b4,0xaea3d1b4,0x0,0x2ea2d134,0x0,0x0,0x0,0xaea3d1b4,0xaea3d1b4,0xaea3d1b4,0xaea3d1b4,0x0,0x0,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0x0,0x1000,0x0,0x2ea2d134,0x0,0x2ea2d134,0x2ea2d134,0x0,0x2ea2d134,0x0,0x2ea2d134,0x2ea2d134,0x600,0x600,0x0,0x600,0x600,0x0,0x0,0x0,0x0,0x20000000,0x0,0x400000,0x0,0x200,0x200,0x0,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x2ea6d134,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x2ea2d134,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x10000200,0x0,0x0,0x0,0x0,0x0,0x0,0x10000200,0x100000,0x0,0x0,0x10000200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x2ea2d134,0x0,0x200000,0x2ea2d134,0x0,0x2ea2d134,0x0,0x0,0x200000,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x2eaad134,0x4,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x0,0x0,0x4000,0x4000,0x0,0x20000,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0xaea3d1b4,0x0,0xffffdbbd,0xffffdbbd,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x0,0x0,0x0,0x1000000,0x0,0x1000000,0x0,0xffffdbbd,0xffffdbbd,0x0,0x20000,0x0,0x0,0x20000,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20020000,0x20020000,0x0,0x0,0x0,0x20000,0x20000,0x0,0x0,0x0,0x1000000,0xffffdbbd,0x0,0xffffdbbd,0x0,0x20000,0x0,0x20000,0x2000,0x0,0x2000,0x0,0x0,0x800000,0x800000,0xffffdbbd,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x10000,0x0,0x10002,0x0,0x10000,0x0,0x10002,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xaea3d1b4,0x0,0x0,0xffffdbbd,0x0,0x0,0xffffdbbd,0x0,0x2,0x0,0x2,0xffffdbbd,0x2,0x0,0x2,0x91550a4b,0x2ea2d134,0xffffdbbd,0x2ea2d134,0x2eaed134,0x240020,0x0,};
40160    }
40161    private static void jj_la1_init_5() {
40162       jj_la1_5 = new int[] {0x20,0x20,0x20,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0xffedffff,0x0,0x0,0x800014,0xffedffff,0xffedffff,0xffedffff,0x0,0xffedffff,0xffedffff,0x0,0xffedffff,0xffedffff,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0xffedffff,0xffedffff,0x0,0x0,0x0,0x0,0xfc49ef7f,0x0,0x0,0x800014,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x800000,0x2800000,0x0,0x0,0x0,0x0,0x0,0x0,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xf800c001,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2100,0x2100,0x0,0x2100,0x0,0x0,0x0,0x6cb6f7e,0x6cb6f7e,0x0,0x20,0x0,0x6cb6f7e,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x6cb6f7e,0x6cb6f7e,0x6cb6f7e,0x6cb6f7e,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x4496f7e,0x0,0x4496f7e,0x0,0x4496f7e,0x6cb6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x800000,0x0,0xf0000000,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0x0,0xfc49ef7f,0x0,0x800000,0x2800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x64b6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800010,0x0,0x0,0x0,0x800000,0x10,0x0,0x10,0x0,0x0,0x0,0x800010,0x0,0x0,0x0,0x0,0x0,0x800,0x800,0x0,0x6cb6f7e,0x6cb6f7e,0x800000,0x0,0x0,0x0,0x0,0x64b6f7e,0x6496f7e,0x64b6f7e,0x0,0x2000000,0x4496f7e,0x0,0x6cb6f7e,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x2800000,0x0,0x80000,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4496f7e,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x800000,0x800000,0x0,0x4,0x4,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0xffedffff,0xffedffff,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0xffedffff,0x0,0x800014,0x0,0x0,0x2800000,0x800000,0x2000000,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x400,0x0,0x0,0x0,0x800014,0x800014,0x0,0x0,0x0,0x800014,0x800014,0x400,0x0,0x0,0x0,0xffedffff,0x0,0xffedffff,0x0,0x2800000,0x800000,0x2000000,0x800000,0x800000,0x800000,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x10000,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0xffedffff,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0xb901081,0x449677c,0xffedffff,0x4496f7e,0xfc6def7f,0xf800e201,0x0,};
40163    }
40164    private static void jj_la1_init_6() {
40165       jj_la1_6 = new int[] {0xa0020000,0x0,0x0,0x0,0x20000000,0x0,0x0,0xcc2b6392,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x800,0x0,0x0,0x0,0x20000,0x0,0xcc2b6392,0x0,0x0,0xfb9bffbf,0x0,0x4000000,0x80011000,0xff9bffbf,0xff9bffbf,0xff9bffbf,0x0,0xff9bffbf,0xff9bffbf,0x0,0xff9bffbf,0xff9bffbf,0x800,0x0,0x0,0x0,0x440000,0x0,0x0,0x0,0x0,0x0,0x1000,0xfb9bffbf,0x0,0x1000,0x1000,0x0,0x0,0x0,0x0,0x440000,0x0,0x0,0x4000000,0xcc2b6392,0x0,0xfb9bffbf,0xff9bffbf,0x0,0x440000,0x8000,0x0,0xcb8b6393,0x0,0x0,0x80011000,0x0,0x0,0x0,0x80000000,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3800001,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0xcc2b6392,0xcc2b6392,0x0,0x0,0x0,0xcc2b6392,0xcc2b6392,0x0,0xc80b6392,0x0,0x0,0x0,0xcc2b6392,0xcc2b6392,0xcc2b6392,0xcc2b6392,0x0,0x0,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0xc80b6392,0xc80b6392,0x0,0xc80b6392,0x0,0xc80b6392,0xc80b6392,0x8000,0x8000,0x0,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x8000,0x8000,0x0,0x8000,0x8000,0x8000,0x0,0x0,0x0,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xcb8b6393,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0xc80b6392,0x0,0x0,0x40,0x0,0x40,0xc80b6392,0xc80b6392,0xc80b6392,0x0,0x0,0xc80b6392,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x1000,0x0,0x1000,0x80020000,0x80020000,0x0,0x80020000,0x80020000,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x800,0x0,0x0,0x0,0xc80b6392,0xc80b6392,0x0,0x0,0x200,0x200,0x0,0x10000,0x0,0x10000,0x1000,0x1000,0x0,0x0,0x40000,0x400000,0x0,0x0,0x0,0xcc2b6392,0x0,0xfb9bffbf,0xff9bffbf,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff9bffbf,0xff9bffbf,0x0,0x11000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x11000,0x11000,0x0,0x0,0x0,0x11000,0x11000,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xcc2b6392,0x0,0x0,0xff9bffbf,0x4000000,0x80000000,0xfb9bffbf,0x0,0x0,0x800,0x0,0xfb9bffbf,0x0,0x0,0x0,0x10101c28,0x880b6192,0xfb9bffbf,0xc80b6392,0xff8be397,0x3800005,0x0,};
40166    }
40167    private static void jj_la1_init_7() {
40168       jj_la1_7 = new int[] {0x25030200,0x5020000,0x5020000,0x0,0x20010000,0x0,0x0,0x2fbeebfe,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfe,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0xbffeebff,0xbffeebff,0xbffeebff,0x0,0xbffeebff,0xbffeebff,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0x1000,0x0,0x0,0x0,0x2fbeebfe,0x0,0xbffeebff,0xbffeebff,0x0,0x1000,0x0,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x2000,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100008,0x100058,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x2000000,0x0,0x2000000,0x0,0x0,0x0,0x2fbeebfe,0x2fbeebfe,0x0,0x25020000,0x0,0x2fbeebfe,0x2fbeebfe,0x0,0x2fbeebfc,0x0,0x0,0x0,0x2fbeebfe,0x2fbeebfe,0x2fbeebfe,0x2fbeebfe,0x0,0x8000,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x0,0x0,0x0,0x2fbeebfc,0x800000,0x2fbeebfc,0x2bbeebfc,0x0,0x2bbeebfc,0x0,0x2bbeebfc,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x0,0x6000,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x4,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x0,0x0,0x2fbeebfc,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x2fbeebfc,0x2fbeebfc,0x0,0x0,0x2bbeebfc,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x2bbeebfc,0x4,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x2bbeebfc,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x2fbeebfe,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10200,0x0,0x0,0x0,0x10200,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x8000,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfe,0x0,0x0,0xbffeebff,0x0,0x0,0xbffeebff,0x0,0x10200,0x0,0x10200,0xbffeebff,0x10200,0x0,0x10200,0xe4010409,0x2bbeebf4,0xbffeebff,0x2bbeebfc,0x3bfeebfe,0x22740078,0x0,};
40169    }
40170    private static void jj_la1_init_8() {
40171       jj_la1_8 = new int[] {0x14000020,0x0,0x0,0x0,0x20,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x5afd675e,0x0,0x0,0x7fffffff,0x0,0x0,0x40,0x7fffffff,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x5afd675f,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x5afd675e,0x0,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x4001,0xc0000,0x0,0x0,0x0,0x0,0x1000000,0x80000,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x5afde75f,0x10000100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x10000000,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x5afd675e,0x0,0x8080000,0x5afd675e,0x0,0x5afd675e,0x40000,0x0,0x8080000,0x8000000,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x14000000,0x14000000,0x0,0x14000000,0x14000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x40000000,0x0,0x7fffffff,0x7fffffff,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x40,0x0,0x0,0x0,0x40,0x40,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x7fffffff,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x85029021,0x4afd4742,0x7fffffff,0x5afd675e,0x7efd7fdb,0xfc8001,0x0,};
40172    }
40173    private static void jj_la1_init_9() {
40174       jj_la1_9 = new int[] {0x400002c0,0x40000200,0x40000200,0x0,0xc0,0x0,0x0,0xfffdf371,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0x0,0xffffff71,0x0,0x0,0x0,0xffffff71,0xffffff71,0xffffff71,0x0,0xffffff71,0xffffff71,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xffffff71,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0xbffffd61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffdf161,0x0,0x0,0xc00000,0x0,0x0,0x0,0x0,0xc3c0c00,0xf3fbc00,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x10000000,0x10000000,0x20000000,0x10000000,0x40000000,0x40000000,0x0,0xfffdf371,0xfffdf371,0x4,0x40000200,0x0,0xfffdf171,0xfffdf371,0x0,0xfffdf161,0x4,0x0,0x0,0xfffdf371,0xfffdf371,0xfffdf371,0xfffdf371,0x0,0x0,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0x0,0x2,0x0,0xfffdf163,0x0,0xfffdf161,0xbffdf161,0x4,0xbffdf161,0x4,0xbffdf161,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc00000,0x0,0x0,0x0,0x0,0x0,0xbffffd61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0xfffdf161,0x0,0x0,0xfffdf161,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0xfffdf161,0xfffdf161,0x0,0x0,0xbffdf161,0x0,0xfffdf161,0x20000000,0x0,0x0,0x0,0x100,0x0,0x0,0xfffdf161,0x0,0x0,0x0,0x1,0xffffff71,0x0,0x0,0x0,0x0,0xbffdf161,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffdf161,0xbffdf161,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x200,0x0,0x200,0x0,0x200,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0xfffdf371,0x0,0x0,0xffffff71,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x40000e0a,0xbfed7161,0xffffff71,0xbffdf161,0xbffffd71,0xff7ffc00,0x0,};
40175    }
40176    private static void jj_la1_init_10() {
40177       jj_la1_10 = new int[] {0xc7000000,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0x0,0xff0000c7,0x0,0x0,0x400,0xff0004c7,0xff0084c7,0xff0084c7,0x2000,0xff0084c7,0xff0084c7,0x1000,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0xff0000c7,0x2000,0x1000,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0x0,0xff0004c7,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0xff0084c7,0x0,0xff0084c7,0x0,0xff0084c7,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0xff0004c7,0xff0000c7,0x0,0xff0000c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x2000,0xff0084c7,0x1000,0xff0084c7,0x8400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x2000,0x1000,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0xff0000c7,0x0,0x0,0xff0000c7,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe,0x0,0x0,0xc7000000,0x0,0x0,0x0,0xc7000000,0x10000000,0xff0000c7,0xc0,0xc0,0x20,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28000000,0xe,0x0,0xff0084c7,0xe,0x0,0xff0000cf,0xe,0x0,0xff0000c7,0x6,0xc7000000,0x0,0xc7000000,0xff0000c7,0xc7000000,0x0,0xc7000000,0x300,0xff0000c7,0xff0000c7,0xff0000c7,0xff0000c7,0x1,0x0,};
40178    }
40179    private static void jj_la1_init_11() {
40180       jj_la1_11 = new int[] {0xfa002020,0x0,0x0,0x0,0xfa000000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x4000000,0x0,0xffffffff,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x4000,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x4004000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x98000,0x0,0x0,0x0,0x0,0x98000,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x33ac,0x0,0x0,0x0,0x33ac,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x401,0xffffffff,0x0,0x401,0xffffffff,0x0,0x0,0xffffffff,0x0,0x33ac,0x0,0x33ac,0xffffffff,0x2020,0x138c,0x33ac,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x4000000,0x0,};
40181    }
40182    private static void jj_la1_init_12() {
40183       jj_la1_12 = new int[] {0x1f,0x0,0x0,0x0,0x1f,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x18800,0x18800,0x1fc7ffff,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x0,0x0,0x0,0x0,0x4000,0x0,0x4000,0x0,0x0,0x0,0x6000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x1fc7ffff,0x0,0x0,0x60000,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x100000,0x100000,0x300000,0x80000,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,};
40184    }
40185    private static void jj_la1_init_13() {
40186       jj_la1_13 = new int[] {0x10,0x0,0x0,0x0,0x10,0x0,0x0,0x1630,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1f010,0x0,0x0,0x10,0x1f010,0x1f010,0x1f010,0x0,0x1f010,0x1f010,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x0,0x0,0x0,0x1630,0x1630,0x0,0x1630,0x0,0x0,0x10,0x1630,0x1630,0x1630,0x1630,0x10,0x0,0x0,0x1630,0x10,0x1630,0x10,0x1630,0x0,0x0,0x0,0x0,0x1630,0x0,0x1630,0x1010,0x0,0x1010,0x0,0x1010,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1630,0x0,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x1410,0x1410,0x0,0x1410,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1630,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x1630,0x0,0x620,0x1010,0x0,0x1630,0x0,0x0,0x620,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x0,0x0,0x1f410,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1410,0x1410,0x0,0x0,0x0,0x0,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f410,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1f010,0x0,0x10,0x1f010,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x1f010,0x1010,0x1010,0x1e000,0xe000,};
40187    }
40188   final private JJCalls[] jj_2_rtns = new JJCalls[84];
40189   private boolean jj_rescan = false;
40190   private int jj_gc = 0;
40191 
40192   /** Constructor with InputStream. */
40193   public PLSQLParser(java.io.InputStream stream) {
40194      this(stream, null);
40195   }
40196   /** Constructor with InputStream and supplied encoding */
40197   public PLSQLParser(java.io.InputStream stream, String encoding) {
40198     try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
40199     token_source = new PLSQLParserTokenManager(jj_input_stream);
40200     token = new Token();
40201     token.next = jj_nt = token_source.getNextToken();
40202     jj_gen = 0;
40203     for (int i = 0; i < 458; i++) jj_la1[i] = -1;
40204     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40205   }
40206 
40207   /** Reinitialise. */
40208   public void ReInit(java.io.InputStream stream) {
40209      ReInit(stream, null);
40210   }
40211   /** Reinitialise. */
40212   public void ReInit(java.io.InputStream stream, String encoding) {
40213     try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
40214     token_source.ReInit(jj_input_stream);
40215     token = new Token();
40216     token.next = jj_nt = token_source.getNextToken();
40217     jjtree.reset();
40218     jj_gen = 0;
40219     for (int i = 0; i < 458; i++) jj_la1[i] = -1;
40220     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40221   }
40222 
40223   /** Constructor. */
40224   public PLSQLParser(java.io.Reader stream) {
40225     jj_input_stream = new SimpleCharStream(stream, 1, 1);
40226     token_source = new PLSQLParserTokenManager(jj_input_stream);
40227     token = new Token();
40228     token.next = jj_nt = token_source.getNextToken();
40229     jj_gen = 0;
40230     for (int i = 0; i < 458; i++) jj_la1[i] = -1;
40231     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40232   }
40233 
40234   /** Reinitialise. */
40235   public void ReInit(java.io.Reader stream) {
40236     jj_input_stream.ReInit(stream, 1, 1);
40237     token_source.ReInit(jj_input_stream);
40238     token = new Token();
40239     token.next = jj_nt = token_source.getNextToken();
40240     jjtree.reset();
40241     jj_gen = 0;
40242     for (int i = 0; i < 458; i++) jj_la1[i] = -1;
40243     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40244   }
40245 
40246   /** Constructor with generated Token Manager. */
40247   public PLSQLParser(PLSQLParserTokenManager tm) {
40248     token_source = tm;
40249     token = new Token();
40250     token.next = jj_nt = token_source.getNextToken();
40251     jj_gen = 0;
40252     for (int i = 0; i < 458; i++) jj_la1[i] = -1;
40253     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40254   }
40255 
40256   /** Reinitialise. */
40257   public void ReInit(PLSQLParserTokenManager tm) {
40258     token_source = tm;
40259     token = new Token();
40260     token.next = jj_nt = token_source.getNextToken();
40261     jjtree.reset();
40262     jj_gen = 0;
40263     for (int i = 0; i < 458; i++) jj_la1[i] = -1;
40264     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40265   }
40266 
40267   private Token jj_consume_token(int kind) throws ParseException {
40268     Token oldToken = token;
40269     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
40270     else jj_nt = jj_nt.next = token_source.getNextToken();
40271     if (token.kind == kind) {
40272       jj_gen++;
40273       if (++jj_gc > 100) {
40274         jj_gc = 0;
40275         for (int i = 0; i < jj_2_rtns.length; i++) {
40276           JJCalls c = jj_2_rtns[i];
40277           while (c != null) {
40278             if (c.gen < jj_gen) c.first = null;
40279             c = c.next;
40280           }
40281         }
40282       }
40283       return token;
40284     }
40285     jj_nt = token;
40286     token = oldToken;
40287     jj_kind = kind;
40288     throw generateParseException();
40289   }
40290 
40291   static private final class LookaheadSuccess extends java.lang.Error { }
40292   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
40293   private boolean jj_scan_token(int kind) {
40294     if (jj_scanpos == jj_lastpos) {
40295       jj_la--;
40296       if (jj_scanpos.next == null) {
40297         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
40298       } else {
40299         jj_lastpos = jj_scanpos = jj_scanpos.next;
40300       }
40301     } else {
40302       jj_scanpos = jj_scanpos.next;
40303     }
40304     if (jj_rescan) {
40305       int i = 0; Token tok = token;
40306       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
40307       if (tok != null) jj_add_error_token(kind, i);
40308     }
40309     if (jj_scanpos.kind != kind) return true;
40310     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
40311     return false;
40312   }
40313 
40314 
40315 /** Get the next Token. */
40316   final public Token getNextToken() {
40317     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
40318     else jj_nt = jj_nt.next = token_source.getNextToken();
40319     jj_gen++;
40320     return token;
40321   }
40322 
40323 /** Get the specific Token. */
40324   final public Token getToken(int index) {
40325     Token t = token;
40326     for (int i = 0; i < index; i++) {
40327       if (t.next != null) t = t.next;
40328       else t = t.next = token_source.getNextToken();
40329     }
40330     return t;
40331   }
40332 
40333   private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
40334   private int[] jj_expentry;
40335   private int jj_kind = -1;
40336   private int[] jj_lasttokens = new int[100];
40337   private int jj_endpos;
40338 
40339   private void jj_add_error_token(int kind, int pos) {
40340     if (pos >= 100) return;
40341     if (pos == jj_endpos + 1) {
40342       jj_lasttokens[jj_endpos++] = kind;
40343     } else if (jj_endpos != 0) {
40344       jj_expentry = new int[jj_endpos];
40345       for (int i = 0; i < jj_endpos; i++) {
40346         jj_expentry[i] = jj_lasttokens[i];
40347       }
40348       jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
40349         int[] oldentry = (int[])(it.next());
40350         if (oldentry.length == jj_expentry.length) {
40351           for (int i = 0; i < jj_expentry.length; i++) {
40352             if (oldentry[i] != jj_expentry[i]) {
40353               continue jj_entries_loop;
40354             }
40355           }
40356           jj_expentries.add(jj_expentry);
40357           break jj_entries_loop;
40358         }
40359       }
40360       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
40361     }
40362   }
40363 
40364   /** Generate ParseException. */
40365   public ParseException generateParseException() {
40366     jj_expentries.clear();
40367     boolean[] la1tokens = new boolean[434];
40368     if (jj_kind >= 0) {
40369       la1tokens[jj_kind] = true;
40370       jj_kind = -1;
40371     }
40372     for (int i = 0; i < 458; i++) {
40373       if (jj_la1[i] == jj_gen) {
40374         for (int j = 0; j < 32; j++) {
40375           if ((jj_la1_0[i] & (1<<j)) != 0) {
40376             la1tokens[j] = true;
40377           }
40378           if ((jj_la1_1[i] & (1<<j)) != 0) {
40379             la1tokens[32+j] = true;
40380           }
40381           if ((jj_la1_2[i] & (1<<j)) != 0) {
40382             la1tokens[64+j] = true;
40383           }
40384           if ((jj_la1_3[i] & (1<<j)) != 0) {
40385             la1tokens[96+j] = true;
40386           }
40387           if ((jj_la1_4[i] & (1<<j)) != 0) {
40388             la1tokens[128+j] = true;
40389           }
40390           if ((jj_la1_5[i] & (1<<j)) != 0) {
40391             la1tokens[160+j] = true;
40392           }
40393           if ((jj_la1_6[i] & (1<<j)) != 0) {
40394             la1tokens[192+j] = true;
40395           }
40396           if ((jj_la1_7[i] & (1<<j)) != 0) {
40397             la1tokens[224+j] = true;
40398           }
40399           if ((jj_la1_8[i] & (1<<j)) != 0) {
40400             la1tokens[256+j] = true;
40401           }
40402           if ((jj_la1_9[i] & (1<<j)) != 0) {
40403             la1tokens[288+j] = true;
40404           }
40405           if ((jj_la1_10[i] & (1<<j)) != 0) {
40406             la1tokens[320+j] = true;
40407           }
40408           if ((jj_la1_11[i] & (1<<j)) != 0) {
40409             la1tokens[352+j] = true;
40410           }
40411           if ((jj_la1_12[i] & (1<<j)) != 0) {
40412             la1tokens[384+j] = true;
40413           }
40414           if ((jj_la1_13[i] & (1<<j)) != 0) {
40415             la1tokens[416+j] = true;
40416           }
40417         }
40418       }
40419     }
40420     for (int i = 0; i < 434; i++) {
40421       if (la1tokens[i]) {
40422         jj_expentry = new int[1];
40423         jj_expentry[0] = i;
40424         jj_expentries.add(jj_expentry);
40425       }
40426     }
40427     jj_endpos = 0;
40428     jj_rescan_token();
40429     jj_add_error_token(0, 0);
40430     int[][] exptokseq = new int[jj_expentries.size()][];
40431     for (int i = 0; i < jj_expentries.size(); i++) {
40432       exptokseq[i] = jj_expentries.get(i);
40433     }
40434     return new ParseException(token, exptokseq, tokenImage);
40435   }
40436 
40437   /** Enable tracing. */
40438   final public void enable_tracing() {
40439   }
40440 
40441   /** Disable tracing. */
40442   final public void disable_tracing() {
40443   }
40444 
40445   private void jj_rescan_token() {
40446     jj_rescan = true;
40447     for (int i = 0; i < 84; i++) {
40448     try {
40449       JJCalls p = jj_2_rtns[i];
40450       do {
40451         if (p.gen > jj_gen) {
40452           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
40453           switch (i) {
40454             case 0: jj_3_1(); break;
40455             case 1: jj_3_2(); break;
40456             case 2: jj_3_3(); break;
40457             case 3: jj_3_4(); break;
40458             case 4: jj_3_5(); break;
40459             case 5: jj_3_6(); break;
40460             case 6: jj_3_7(); break;
40461             case 7: jj_3_8(); break;
40462             case 8: jj_3_9(); break;
40463             case 9: jj_3_10(); break;
40464             case 10: jj_3_11(); break;
40465             case 11: jj_3_12(); break;
40466             case 12: jj_3_13(); break;
40467             case 13: jj_3_14(); break;
40468             case 14: jj_3_15(); break;
40469             case 15: jj_3_16(); break;
40470             case 16: jj_3_17(); break;
40471             case 17: jj_3_18(); break;
40472             case 18: jj_3_19(); break;
40473             case 19: jj_3_20(); break;
40474             case 20: jj_3_21(); break;
40475             case 21: jj_3_22(); break;
40476             case 22: jj_3_23(); break;
40477             case 23: jj_3_24(); break;
40478             case 24: jj_3_25(); break;
40479             case 25: jj_3_26(); break;
40480             case 26: jj_3_27(); break;
40481             case 27: jj_3_28(); break;
40482             case 28: jj_3_29(); break;
40483             case 29: jj_3_30(); break;
40484             case 30: jj_3_31(); break;
40485             case 31: jj_3_32(); break;
40486             case 32: jj_3_33(); break;
40487             case 33: jj_3_34(); break;
40488             case 34: jj_3_35(); break;
40489             case 35: jj_3_36(); break;
40490             case 36: jj_3_37(); break;
40491             case 37: jj_3_38(); break;
40492             case 38: jj_3_39(); break;
40493             case 39: jj_3_40(); break;
40494             case 40: jj_3_41(); break;
40495             case 41: jj_3_42(); break;
40496             case 42: jj_3_43(); break;
40497             case 43: jj_3_44(); break;
40498             case 44: jj_3_45(); break;
40499             case 45: jj_3_46(); break;
40500             case 46: jj_3_47(); break;
40501             case 47: jj_3_48(); break;
40502             case 48: jj_3_49(); break;
40503             case 49: jj_3_50(); break;
40504             case 50: jj_3_51(); break;
40505             case 51: jj_3_52(); break;
40506             case 52: jj_3_53(); break;
40507             case 53: jj_3_54(); break;
40508             case 54: jj_3_55(); break;
40509             case 55: jj_3_56(); break;
40510             case 56: jj_3_57(); break;
40511             case 57: jj_3_58(); break;
40512             case 58: jj_3_59(); break;
40513             case 59: jj_3_60(); break;
40514             case 60: jj_3_61(); break;
40515             case 61: jj_3_62(); break;
40516             case 62: jj_3_63(); break;
40517             case 63: jj_3_64(); break;
40518             case 64: jj_3_65(); break;
40519             case 65: jj_3_66(); break;
40520             case 66: jj_3_67(); break;
40521             case 67: jj_3_68(); break;
40522             case 68: jj_3_69(); break;
40523             case 69: jj_3_70(); break;
40524             case 70: jj_3_71(); break;
40525             case 71: jj_3_72(); break;
40526             case 72: jj_3_73(); break;
40527             case 73: jj_3_74(); break;
40528             case 74: jj_3_75(); break;
40529             case 75: jj_3_76(); break;
40530             case 76: jj_3_77(); break;
40531             case 77: jj_3_78(); break;
40532             case 78: jj_3_79(); break;
40533             case 79: jj_3_80(); break;
40534             case 80: jj_3_81(); break;
40535             case 81: jj_3_82(); break;
40536             case 82: jj_3_83(); break;
40537             case 83: jj_3_84(); break;
40538           }
40539         }
40540         p = p.next;
40541       } while (p != null);
40542       } catch(LookaheadSuccess ls) { }
40543     }
40544     jj_rescan = false;
40545   }
40546 
40547   private void jj_save(int index, int xla) {
40548     JJCalls p = jj_2_rtns[index];
40549     while (p.gen > jj_gen) {
40550       if (p.next == null) { p = p.next = new JJCalls(); break; }
40551       p = p.next;
40552     }
40553     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
40554   }
40555 
40556   static final class JJCalls {
40557     int gen;
40558     Token first;
40559     int arg;
40560     JJCalls next;
40561   }
40562 
40563 }